python-入門語法.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UQI1RIaNdz0R"
      },
      "source": [
        "# Python-入門語法\n",
        "上次更新：2023.02.25 \n",
        "## 教學目標\n",
        "\n",
        "這份教學的目標是介紹基本的 python 語法。\n",
        "\n",
        "## 適用對象\n",
        "\n",
        "- 有程式基礎，但是卻沒有學過 python。\n",
        "- 有學過 Python，但很久沒有寫了、語法忘光光。\n",
        "\n",
        "\n",
        "請先參考 [jupyter-基本功能](./jupyter-基本功能.ipynb) 教學了解如何與當前教學環境互動。\n",
        "如從 colab 打開，請開啟新的筆記本並使用 Github 貼上 Course Materials 底下的 [`jupyter-基本功能.ipynb` 連結](https://github.com/IKMLab/course_material/blob/master/jupyter-%E5%9F%BA%E6%9C%AC%E5%8A%9F%E8%83%BD.ipynb)。\n",
        "\n",
        "## 執行時間\n",
        "\n",
        "本教學全部執行時間約為 3.0717861652374268 秒。\n",
        "\n",
        "|測試環境|名稱|\n",
        "|-|-|\n",
        "|主機板|X570 AORUS ELITE|\n",
        "|處理器|AMD Ryzen 7 3700X 8-Core Processor|\n",
        "|記憶體|Kingston KHX3200C16D4/16GX|\n",
        "|硬碟|Seagate ST1000DM003-1ER1|\n",
        "|顯示卡|GeForce RTX 2080|\n",
        "|作業系統|Ubuntu 18.04 LTS|"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yrAXZufsdz0X"
      },
      "source": [
        "## 大綱 (Outline)\n",
        "\n",
        "- [I. 四則運算](#scrollTo=C0oZY4Mxdz0Y&line=1&uniqifier=1)\n",
        "- [II. 變數](#scrollTo=qpCaHccGdz0b)\n",
        "- [III. 資料型態](#scrollTo=qq1yzoiKdz0c)\n",
        "- [IV. 條件判斷](#scrollTo=gqrsKE57dz0f&line=1&uniqifier=1)\n",
        "- [V. 迴圈](#scrollTo=y6WsDqSCdz0g&line=1&uniqifier=1)\n",
        "- [VI. 函數](#scrollTo=RVQjYiYGdz0g)\n",
        "- [VII. 類別](#scrollTo=1Aj66FpVdz0i)\n",
        "- [VIII. 模組](#scrollTo=lF9CTdPUdz0j)\n",
        "- [IX. 錯誤處理](#scrollTo=g0b_2Q4ddz0j)\n",
        "<!-- - [X. Typing](#Typing) -->\n",
        "<!-- - [XI. Formatter](#Formatter) -->"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C0oZY4Mxdz0Y"
      },
      "source": [
        "## 四則運算（Arithmetic Operations）\n",
        "\n",
        "### 註解\n",
        "\n",
        "`#` 井號的意思是**註解**，出現在井號之後的任何文字都**不會**被當作程式執行\n",
        "\n",
        "### 輸出\n",
        "\n",
        "`print()` 的功能為**輸出**運算結果\n",
        "\n",
        "### 算術運算子（arithmetic operator）\n",
        "\n",
        "|符號|名稱|範例|\n",
        "|-|-|-|\n",
        "|`+`|加法|`a + b`|\n",
        "|`-`|減法|`a - b`|\n",
        "|`*`|乘法|`a * b`|\n",
        "|`/`|除法|`a / b`|\n",
        "|`//`|整除|`a // b`| \n",
        "|`%`|餘數|`a % b`|\n",
        "|`**`|指數|`a ** b`|\n",
        "\n",
        "- **整數相除** `/` 會變成含有小數點的**浮點數**\n",
        "    - 如果**只想要整數**的部份（取得商數），請使用 `//`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yo0kN9ITdz0Z",
        "outputId": "6b598320-3f78-4055-db04-309ea02efdcc"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1995\n",
            "10\n",
            "12\n",
            "1.3333333333333333\n"
          ]
        }
      ],
      "source": [
        "# 井號的意思是註解\n",
        "# 可以出現在每一行的任何一個地方\n",
        "# 出現在井號之後的任何文字都不會被當作程式執行\n",
        "\n",
        "# print 的功能是輸出\n",
        "# 如同 C 語言中的 printf\n",
        "# 如同 C++ 語言中的 std::cout\n",
        "# 如同 Java 語言中的 System.out.println\n",
        "\n",
        "# 相加輸出 1995\n",
        "print(1234 + 761)  \n",
        "# 相減輸出 10\n",
        "print(5678 - 5668) \n",
        "# 相乘輸出 12\n",
        "print(3 * 4)       \n",
        "# 相除輸出 1.3333333333333333\n",
        "print(4 / 3)       "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "5\n",
            "166\n",
            "4096\n"
          ]
        }
      ],
      "source": [
        "# 餘數運算\n",
        "# 輸出 5\n",
        "print(1995 % 10)  \n",
        "\n",
        "# 整除運算\n",
        "# 輸出 166\n",
        "print(1995 // 12) \n",
        "\n",
        "# 次方運算\n",
        "# 輸出 4096\n",
        "print(2 ** 12)    "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1685\n",
            "19380\n"
          ]
        }
      ],
      "source": [
        "# 先乘除、後加減\n",
        "# 輸出 1685\n",
        "print(19 * 95 - 10 * 12)   \n",
        "\n",
        "# 使用小括號 ()，改變運算順序\n",
        "# 輸出 19380\n",
        "print(19 * (95 - 10) * 12) "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OMDKrJr-m4YA"
      },
      "source": [
        "### 浮點數（floating point precision） \n",
        "    - [浮點數官方文件](https://docs.python.org/3/tutorial/floatingpoint.html)\n",
        "    - 浮點數以 base 2 儲存，不像整數、很多 base 10 的浮點數無法被精確的表示，故這些變數內儲存的值只是 \"approximation of the original decimal fraction\"。\n",
        "    - 比較兩值是否『相等』可能因此出現問題，通常會使用 『兩數相減後的餘值的絕對值，是否小於某個極小值』的方式檢視，該方法稱作 absolute margin comparison，其他方法可以參考 [The Little Things: Comparing Floating Point Numbers](https://www.bing.com/search?q=Comparing+Floating+Point+Numbers&aqs=edge..69i57j69i60&FORM=ANCMS9&PC=U531)。"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iGv1QNjdfObN",
        "outputId": "f7a77c4f-a0f5-475a-8698-04819938e934"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "0.30000000000000004\n",
            "Direct Comparison:\t\n",
            "False\n",
            "Absolute Margin Comparison:\t\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 20,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# floating point precision issue \n",
        "print(0.1 + 0.2)\n",
        "# Directly compare -> False\n",
        "print(\"Direct Comparison:\\t\")\n",
        "print(0.1 + 0.2 == 0.3)\n",
        "\n",
        "# Absolute margin comparison -> True  \n",
        "print(\"Absolute Margin Comparison:\\t\")\n",
        "epsilon = 1e-10 # 10^(-10)\n",
        "abs((0.1 + 0.2) - 0.3) < epsilon  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VjCpj5nflhO7"
      },
      "source": [
        "### 大數（bignum）\n",
        "- 電腦系統可儲存的數字的大小有其極限。假設一個 integer 以 4 bytes 的形式儲存的話，總共有 32 bits 可以用。$2^{32}$ 可能的值，$2^{31}$ 個值為負數表示，一個值保留給 0，另外 $2^{31}- 1$ 個值為正數表示。故在程式語言中 integer 也有其範圍，以下為一段 C++ 程式片段，用來檢視整數範圍（注意：可能因為 compilers 不同有差異）。當你定義的數字超過該值（大於 `INT_MAX` 或小於 `INT_MIN`）則會導致 overflow 問題。\n",
        "```C++\n",
        "// C++ program to print values of INT_MAX\n",
        "// and INT_MIN\n",
        "#include <bits/stdc++.h>\n",
        "using namespace std;\n",
        "int main()\n",
        "{\n",
        "    cout << INT_MAX << endl; // +2147483647 二十一億...\n",
        "    cout << INT_MIN;         // -2147483648\n",
        "    return 0;\n",
        "}\n",
        "```\n",
        "\n",
        "- 在 Python2 中有 `sys.maxint`可以檢視最大整數值，Python3 中為了便利使用，其內部會自動將超出系統範圍的數字轉為大數（bignum）型別，bignum 的運算會以 string 進行，詳細可以參考 [(Github Repo) Limeoats/BigNumber](https://github.com/Limeoats/BigNumber) 或上網搜尋 「C/C++ 大數運算」。意即，你可以嘗試在 Python3 中使用非常大的數字進行運算，不會出現 overflow 或是計算錯誤的問題。\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0f_k2i13vS2J",
        "outputId": "6ea4d862-9bcf-4f3c-b09a-f474e35b6c21"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "9223372036854775807\n"
          ]
        }
      ],
      "source": [
        "\"\"\"\n",
        "The sys.maxint constant was removed, \n",
        "since there is no longer a limit to the value of integers.\n",
        "However, sys.maxsize can be used as an integer larger than any practical list or string index. \n",
        "It conforms to the implementation’s “natural” integer size and is typically the same as sys.maxint in previous releases on the same platform \n",
        "(assuming the same build options).\n",
        "Reference: Python3 documentation: https://docs.python.org/3/whatsnew/3.0.html#integers\n",
        "\"\"\"\n",
        "\n",
        "import sys \n",
        "print(sys.maxsize)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AMmiOAw6kkv2",
        "outputId": "7441de4e-4ed3-4f9b-e44e-c3bd428b7db6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "24\n",
            "28\n",
            "28\n",
            "28\n",
            "28\n",
            "28\n",
            "28\n",
            "28\n",
            "28\n",
            "28\n",
            "\n",
            "28\n",
            "40\n",
            "44\n"
          ]
        }
      ],
      "source": [
        "# ======================\n",
        "from sys import getsizeof \n",
        "for i in range(10):\n",
        "  print(getsizeof(i))\n",
        "print() \n",
        "# =======================\n",
        "# each time a new integer is created, Python uses the memory pointed at by next and increments next to point to the next free integer object in the block.\n",
        "# Once you exceed the storage capacity of an ordinary integer, the size of an int gets larger.\n",
        "# The variability in integer size in Python 3 is a hint that they may behave more like variable-length types (like lists). \n",
        "# Zero is represented not by a stored value, but by an object with size zero\n",
        "# Reference: https://stackoverflow.com/questions/10365624/sys-getsizeofint-returns-an-unreasonably-large-value\n",
        "\n",
        "# https://github.com/python/cpython/blob/ba85d69a3e3610bdd05f0dd372cf4ebca178c7fb/Include/longintrepr.h#L70 \n",
        "print(getsizeof(-100))\n",
        "\n",
        "big_num = 23443258762641253523294644864312470\n",
        "bigger_num = big_num * 10000\n",
        "print(getsizeof(big_num))\n",
        "print(getsizeof(bigger_num)) # byte(s)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qpCaHccGdz0b"
      },
      "source": [
        "# 變數 （Variable）\n",
        "\n",
        "### 變數宣告 (Variable Declaration)\n",
        "\n",
        "- 將計算結果**保存**\n",
        "    - 使用 `=` 進行**賦予 (assignment)** 值的運算\n",
        "- **重複**利用計算結果\n",
        "- 複雜的計算可以拆解成簡單的步驟\n",
        "\n",
        "### 命名規則\n",
        "\n",
        "- **開頭**只能是**非數字的文字**\n",
        "- 不可以包含英文中常見的標點符號\n",
        "- 不可以包含運算符號"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RQTurznGdz0b",
        "outputId": "ca19c748-5fca-4478-ac04-a3bff31ecdc2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "6\n",
            "5\n",
            "3.5\n"
          ]
        }
      ],
      "source": [
        "# 宣告變數 a 並賦予值 1\n",
        "a = 1            \n",
        "# 宣告變數 b 並賦予值 2\n",
        "b = 2            \n",
        "# 宣告變數 c 並賦予值 3\n",
        "c = 3            \n",
        "\n",
        "# 輸出 6\n",
        "print(a + b + c) \n",
        "# 輸出 5\n",
        "print(a * b + c) \n",
        "# 輸出 3.5\n",
        "print(a / b + c) "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bnCRENTcdz0c",
        "outputId": "bba7515b-09ef-4418-e5ae-b41ed9f502fa"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "32\n"
          ]
        }
      ],
      "source": [
        "# 中文也可以作為變數名稱\n",
        "# 只在 python3 有效\n",
        "底數 = 2\n",
        "次方數 = 5\n",
        "運算結果 = 底數 ** 次方數\n",
        "\n",
        "# 輸出 32\n",
        "print(運算結果) "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qq1yzoiKdz0c"
      },
      "source": [
        "## 資料型態（Data Type）\n",
        "\n",
        "- 包含**數值**型態、**結構**型態\n",
        "\n",
        "### 數值型態\n",
        "\n",
        "|型態|名稱|備註|\n",
        "|-|-|-|\n",
        "|`int`|整數||\n",
        "|`float`|浮點數|雙精度|\n",
        "|`bool`|布林值|`True` 或 `False`|\n",
        "|`str`|字串||\n",
        "\n",
        "- 不同型態混合運算有特別規則\n",
        "    - 整數 + 浮點數 = 浮點數\n",
        "    - 浮點數 + 整數 = 浮點數\n",
        "    - `True` 可以變成整數 `1`\n",
        "    - `False` 可以變成整數 `0`\n",
        "- python 為**強型態語言（Strong Type Language）**\n",
        "    - Strong typing means that the type of a value doesn't change in unexpected ways. A string containing only digits doesn't magically become a number, as may happen in Perl. Every change of type requires an explicit conversion. [Reference on StackOverflow](https://stackoverflow.com/questions/11328920/is-python-strongly-typed#:~:text=Python%20is%20strongly%2C%20dynamically%20typed.%20Strong%20typing%20means,become%20a%20number%2C%20as%20may%20happen%20in%20Perl.)\n",
        "    - 字串只能與字串相加（串接/concatenate），串接完的結果仍然為字串（string） 。\n",
        "    - 若其他型態變數要與字串串接，則必須先透過 `str()` 轉變型態成字串。"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hKvWDpICzUvr",
        "outputId": "cbe0fe51-207f-43f4-f697-be32970341cf"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Hellow World\n",
            "<class 'str'>\n"
          ]
        }
      ],
      "source": [
        "prefix = \"Hellow\"\n",
        "suffix = \"World\"\n",
        "print(prefix + \" \" + suffix)\n",
        "print(type(prefix + \" \" + suffix))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "YT-ljzuixxzx",
        "outputId": "68aaa5ff-6669-41e9-830f-e9bde8c3b390"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'1011'"
            ]
          },
          "execution_count": 26,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "a = \"10\"\n",
        "b = \"11\"\n",
        "a + b "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TPucge0dIrs1",
        "outputId": "de9a435d-eea8-47a9-fd21-af24ca00c366"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "unsupported operand type(s) for +: 'int' and 'str'\n"
          ]
        }
      ],
      "source": [
        "a = 10 \n",
        "b = \" students\"\n",
        "try: \n",
        "  a + b \n",
        "except TypeError as err:\n",
        "  print(err) \n",
        "  # TypeError: unsupported operand type(s) for +: 'int' and 'str'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "RPvbzTd2I3ls",
        "outputId": "bacfdccb-2d08-487d-beca-90f6f7b3d31a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'10 students'"
            ]
          },
          "execution_count": 28,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "str(a) + b"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DraAHPXGzZ7A"
      },
      "source": [
        "\n",
        "### 結構型態\n",
        "\n",
        "|型態|名稱|語法|可否更改內容|\n",
        "|-|-|-|-|\n",
        "|`list`|串列|`[]`|mutable|\n",
        "|`tuple`|多元組|`()`|immutable|\n",
        "|`dict`|字典|`{}`|mutable|\n",
        "\n",
        "- `list`\n",
        "    - 類似於 C-like 語言中的 array\n",
        "    - 有**順序**的保存資料\n",
        "    - 使用**位置(數字)**取得內容\n",
        "    - 使用 `:` 來取得指定位置範圍中的資料\n",
        "    - 建議只用來儲存相同性質的資料\n",
        "- `tuple`\n",
        "    - 類似於 C-like 語言中的 const array\n",
        "    - 類似於 `list` ，有**順序**的保存資料\n",
        "    - 其使用方式大致上與 `list` 相同，惟**無法變更個別元素的值**\n",
        "    - 創建方式：（摘錄自 [Python 3.11 的文件](https://docs.python.org/3/library/stdtypes.html?highlight=tuple#tuple)）\n",
        "      ```\n",
        "      Tuples may be constructed in a number of ways:\n",
        "            - Using a pair of parentheses to denote the empty tuple: ()\n",
        "            - Using a trailing comma for a singleton tuple: a, or (a,)\n",
        "            - Separating items with commas: a, b, c or (a, b, c)\n",
        "            - Using the tuple() built-in: tuple() or tuple(iterable)\n",
        "      ```\n",
        "\n",
        "- `dict`\n",
        "    - **無**順序的保存資料\n",
        "    - 使用任意**數值型態**作為**鑰匙（鍵，key）** 取得**配對值（value）**\n",
        "\n",
        "\n",
        "### 資料運算\n",
        "\n",
        "- 可以使用 `type` 觀察變數**資料型態**\n",
        "- 可以使用 `len()` 取得結構型態變數的**大小**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vEihboAmdz0c",
        "outputId": "21bb1a9d-ff5f-4d9c-e9ae-43de6fc2c377"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1\n",
            "<class 'int'>\n",
            "True\n",
            "1.0\n",
            "<class 'float'>\n",
            "True\n",
            "True\n",
            "<class 'bool'>\n",
            "True\n",
            "False\n",
            "<class 'bool'>\n",
            "True\n",
            "apple\n",
            "<class 'str'>\n",
            "True\n"
          ]
        }
      ],
      "source": [
        "# 數值型態\n",
        "\n",
        "# 輸出 1\n",
        "print(1)                    \n",
        "# 輸出 <class 'int'>\n",
        "print(type(1))              \n",
        "# 輸出 True\n",
        "print(type(1) == int)       \n",
        "\n",
        "# 輸出 1.0\n",
        "print(1.0)                  \n",
        "# 輸出 <class 'float'>\n",
        "print(type(1.0))            \n",
        "# 輸出 True: the equivalence holds \n",
        "print(type(1.0) == float)   \n",
        "\n",
        "# 輸出 True\n",
        "print(True)                \n",
        "# 輸出 <class 'bool'> \n",
        "print(type(True))          \n",
        "# 輸出 True: the equivalence holds \n",
        "print(type(True) == bool)   \n",
        "\n",
        "# 輸出 False\n",
        "print(False)                \n",
        "# 輸出 <class 'bool'>\n",
        "print(type(False))          \n",
        "# 輸出 True\n",
        "print(type(False) == bool) # subclass of class int   \n",
        "\n",
        "# 輸出 apple\n",
        "print('apple')              \n",
        "# 輸出 <class 'str'>\n",
        "print(type('apple'))        \n",
        "# 輸出 True\n",
        "print(type('apple') == str) "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CWe2yJ_Jdz0d",
        "outputId": "537d3a1f-e556-4f3a-9c5a-a3dd67ccd530"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2.0\n",
            "2.0\n",
            "2\n",
            "2\n",
            "1\n",
            "1\n",
            "abc\n",
            "年份: 1995\n",
            "月份: 10, 日期: 12\n",
            "月份: 10, 日期: 12\n",
            "月份: 10, 日期: 12\n"
          ]
        }
      ],
      "source": [
        "# 數值型態混合運算\n",
        "\n",
        "# 輸出 2.0\n",
        "print(1 + 1.0)                           \n",
        "# 輸出 2.0\n",
        "print(1.0 + 1)                           \n",
        "\n",
        "# 輸出 2\n",
        "print(1 + True)                          \n",
        "# 輸出 2\n",
        "print(True + 1)                          \n",
        "# 輸出 1\n",
        "print(1 + False)                         \n",
        "# 輸出 1\n",
        "print(False + 1)                         \n",
        "\n",
        "# 輸出 abc\n",
        "print('abc')                             \n",
        "# 輸出 年份: 1995\n",
        "print('年份: ' + str(1995))               \n",
        "# 輸出 月份: 10, 日期: 12\n",
        "print('月份: {}, 日期: {}'.format(10, 12)) \n",
        "# f-string \n",
        "month = 10 \n",
        "date = 12\n",
        "print(f'月份: {month}, 日期: {date}')\n",
        "d = {'month': month, 'date': date}\n",
        "print(f\"月份: {d['month']}, 日期: {d['date']}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z1t6D8jR40vU"
      },
      "source": [
        "### 列表（List）"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bG4bJjm5dz0d",
        "outputId": "f1ec8158-8529-4b18-fc2b-7f181b8e1392"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1995, 10, 12]\n",
            "3\n",
            "1995\n",
            "10\n",
            "12\n"
          ]
        }
      ],
      "source": [
        "# list 結構型態\n",
        "\n",
        "# 宣告 list 結構變數\n",
        "l1 = [1995, 10, 12] \n",
        "\n",
        "# 輸出 list l1 的所有內容 [1995, 10, 12]\n",
        "print(l1)           \n",
        "# 輸出 list l1 的內容大小 3\n",
        "print(len(l1))      \n",
        "# 輸出 list l1 中的第 0 個位置的值 1995\n",
        "print(l1[0])        \n",
        "# 輸出 list l1 中的第 1 個位置的值 10\n",
        "print(l1[1])        \n",
        "# 輸出 list l1 中的第 2 個位置的值 12\n",
        "print(l1[2])        "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mzjkJyqtdz0d",
        "outputId": "ec492a3b-71e5-4166-f845-6f7ed6ce0d21"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "12\n",
            "10\n",
            "1995\n"
          ]
        }
      ],
      "source": [
        "# 宣告 list 結構變數\n",
        "l2 = [1995, 10, 12] \n",
        "\n",
        "# 使用負數來代表反向取得值\n",
        "# 例如長度為 3 的 list l2 中\n",
        "# l2[-1] = l2[len(l2)-1] = l2[3-1] = l2[2] = 12\n",
        "# l2[-2] = l2[len(l2)-2] = l2[3-2] = l2[1] = 10\n",
        "# l2[-3] = l2[len(l2)-3] = l2[3-3] = l2[0] = 1995\n",
        "\n",
        "# 輸出 list l2 中的第 -1 個位置的值 12\n",
        "print(l2[-1])       \n",
        "# 輸出 list l2 中的第 -2 個位置的值 10\n",
        "print(l2[-2])       \n",
        "# 輸出 list l2 中的第 -3 個位置的值 1995\n",
        "print(l2[-3])       "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-8oBDDRKdz0d",
        "outputId": "940ac463-933d-4518-d993-ba5dbce73bf0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1995, 10, 12]\n",
            "[10, 12]\n",
            "[1995, 10]\n",
            "[1995, 10, 12]\n",
            "[1995, 10, 12]\n",
            "[1995, 12]\n",
            "[12, 10, 1995]\n"
          ]
        }
      ],
      "source": [
        "# 宣告 list 結構變數\n",
        "l3 = [1995, 10, 12] \n",
        "\n",
        "# 使用 [起始位置:結束位置] 來取得 list 中的部分值\n",
        "# 取出的值會以 list 的形式保留\n",
        "# 位置包含起始位置，但不包含結束位置\n",
        "\n",
        "# 輸出由 list l3 位置 0, 1, 2 但是不含位置 3 的值所組成的 (sub) list [1995, 10, 12]\n",
        "# list slicing \n",
        "print(l3[0:3])      \n",
        "# 輸出由 list l3 位置 1, 2 的值所組成的  (sub) list [10, 12]\n",
        "print(l3[1:])       \n",
        "# 輸出由 list l3 位置 0, 1 但是不含位置 2 的值所組成的 (sub) list [1995, 10]\n",
        "print(l3[:2])       \n",
        "# 輸出由 list l3 位置 0, 1, 2 的值所組成的 (sub) list [1995, 10, 12]\n",
        "print(l3[:])  \n",
        "\n",
        "# 輸出由 list 位置 0, 1, 2 的值，且間隔為 1 所組成的 (sub) list [1995, 10, 12]\n",
        "print(l3[0:3:1])\n",
        "# 輸出由 list 位置 0, 1, 2 的值，且間隔為 2 所組成的 (sub) list [1995, 12]\n",
        "print(l3[::2])  \n",
        "\n",
        "# reverse the list \n",
        "print(l3[::-1])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 242,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vrg_9Kgedz0e",
        "outputId": "8645b2da-84f8-444e-b147-a103930bbfec"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[2020, 10, 12]\n",
            "[2020, 10, 12, 1995]\n",
            "[2020, 10, 12, 1995, 420, 69]\n",
            "[2020, 10, 12, 1995, 420, 69]\n",
            "[320, 773]\n",
            "[2020, 10, 12, 1995, 420, 69, 320, 773]\n"
          ]
        }
      ],
      "source": [
        "# 宣告 list 結構變數\n",
        "l4 = [1995, 10, 12]  \n",
        "\n",
        "# 更改指定位置的值\n",
        "l4[0] = 2020         \n",
        "# 輸出更改後的 list l4 [2020, 10, 12]\n",
        "print(l4)            \n",
        "\n",
        "# 在 list l4 尾端插入一個值\n",
        "l4.append(1995)      \n",
        "# 輸出 [2020, 10, 12, 1995]\n",
        "print(l4)            \n",
        "\n",
        "# 將 list [420, 69] 串接到 list l4 尾端\n",
        "l4.extend([420, 69]) \n",
        "# 輸出 [2020, 10, 12, 1995, 420, 69]\n",
        "print(l4)\n",
        "\n",
        "l5 = [320, 773]\n",
        "# 使用加號將兩個 list 串接，並將串接後的結果指定給 l6\n",
        "l6 = l4 + l5\n",
        "print(l4)\n",
        "print(l5)\n",
        "print(l6)         "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K9f0oc085EtH"
      },
      "source": [
        "### 元組（Tuple）"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 243,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4QDFrQZydz0e",
        "outputId": "5a7bf574-d343-4d6e-b80b-3a2926f633e9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(1, 2, 3, 4, 5)\n",
            "5\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ]
        }
      ],
      "source": [
        "# tuple 結構型態\n",
        "\n",
        "# 宣告 tuple 結構變數\n",
        "# 可以寫成 t1 = 1, 2, 3, 4, 5 小括號可有可無\n",
        "t1 = (1, 2, 3, 4, 5)                 \n",
        "# 輸出 tuple t1 的所有內容 (1, 2, 3, 4, 5)\n",
        "print(t1)            \n",
        "# 輸出 tuple t1 的內容大小 5\n",
        "print(len(t1))       \n",
        "# 輸出 tuple t1 中的第 0 個位置的值 1\n",
        "print(t1[0])         \n",
        "# 輸出 tuple t1 中的第 1 個位置的值 2\n",
        "print(t1[1])         \n",
        "# 輸出 tuple t1 中的第 2 個位置的值 3\n",
        "print(t1[2])         \n",
        "# 輸出 tuple t1 中的第 3 個位置的值 4\n",
        "print(t1[3])         \n",
        "# 輸出 tuple t1 中的第 3 個位置的值 5\n",
        "print(t1[4])   "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 244,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YNSR8-Vddz0e",
        "outputId": "2c096d3d-e308-44f4-b201-2973884e5bdf"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "5\n",
            "4\n",
            "3\n",
            "2\n",
            "1\n",
            "\n",
            "'tuple' object does not support item assignment\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "(2, 3, 4)"
            ]
          },
          "execution_count": 244,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# 宣告 tuple 結構變數\n",
        "t2 = (1, 2, 3, 4, 5) \n",
        "\n",
        "# 使用負數來代表反向取得值\n",
        "# 例如長度為 5 的 tuple t2 中\n",
        "# t2[-1] = t2[len(t2)-1] = t2[5-1] = t2[4] = 5\n",
        "# t2[-2] = t2[len(t2)-2] = t2[5-2] = t2[3] = 4\n",
        "# t2[-3] = t2[len(t2)-3] = t2[5-3] = t2[2] = 3\n",
        "# t2[-4] = t2[len(t2)-4] = t2[5-4] = t2[1] = 2\n",
        "# t2[-5] = t2[len(t2)-5] = t2[5-5] = t2[0] = 1\n",
        "\n",
        "# 輸出 tuple t2 中的第 -1 個位置的值 5\n",
        "print(t2[-1])        \n",
        "# 輸出 tuple t2 中的第 -2 個位置的值 4\n",
        "print(t2[-2])        \n",
        "# 輸出 tuple t2 中的第 -3 個位置的值 3\n",
        "print(t2[-3])        \n",
        "# 輸出 tuple t2 中的第 -4 個位置的值 2\n",
        "print(t2[-4])        \n",
        "# 輸出 tuple t2 中的第 -5 個位置的值 1\n",
        "print(t2[-5])       \n",
        "\n",
        "print()\n",
        "# 修改 \n",
        "# 不可以修改單一元素值\n",
        "try:\n",
        "  t2[0] = 2\n",
        "except TypeError as e:\n",
        "  print(e)\n",
        "# 連接組合\n",
        "ta = (2,3)\n",
        "tb = (4,) # please note that declaring (4) will be declaring an integer\n",
        "ta + tb "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 245,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ALqrPBEz03fe",
        "outputId": "5a00b9b3-2769-40ef-d3cd-0318691af7b3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1 <class 'int'>\n",
            "(1,) <class 'tuple'>\n"
          ]
        }
      ],
      "source": [
        "# 有沒有加 comma 差很多：\n",
        "a = 1\n",
        "# a = (1) \n",
        "b = 1, \n",
        "print(a, type(a))\n",
        "print(b, type(b))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 246,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PpN6v6R2dz0e",
        "outputId": "c1ff4b33-9c85-4825-9c40-60ffd88ea6d7"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(1, 2, 3)\n",
            "(2, 3, 4, 5)\n",
            "(1, 2)\n",
            "(1, 2, 3, 4, 5)\n"
          ]
        }
      ],
      "source": [
        "# 宣告 tuple 結構變數\n",
        "t3 = (1, 2, 3, 4, 5) \n",
        "\n",
        "# 使用 [起始位置:結束位置] 來取得 tuple 中的部分值\n",
        "# 取出的值會以 tuple 的形式保留\n",
        "# 位置包含起始位置，但不包含結束位置\n",
        "\n",
        "# 輸出由 tuple t3 位置 0, 1, 2 但是不含位置 3 的值所組成的 tuple (1, 2, 3)\n",
        "print(t3[0:3])       \n",
        "# 輸出由 tuple t3 位置 1, 2, 3, 4 的值所組成的 tuple (2, 3, 4, 5)\n",
        "print(t3[1:])        \n",
        "# 輸出由 tuple t3 位置 0, 1 但是不含位置 2 的值所組成的 tuple (1, 2)\n",
        "print(t3[:2])        \n",
        "# 輸出由 tuple t3 位置 0, 1, 2, 3, 4 的值所組成的 tuple (1, 2, 3, 4, 5)\n",
        "print(t3[:])         "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 247,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2E84lgnGdz0e",
        "outputId": "fcdd549a-69d4-40a2-9f37-5bcd923aab0d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "'tuple' object does not support item assignment\n",
            "(1, 2, 3, 4, 5)\n"
          ]
        }
      ],
      "source": [
        "# 宣告 tuple 結構變數\n",
        "t4 = (1, 2, 3, 4, 5) \n",
        "\n",
        "# 無法更改指定位置的值\n",
        "\n",
        "try:\n",
        "    # 得到錯誤 TypeError: 'tuple' object does not support item assignment\n",
        "    t4[0] = 1995 \n",
        "except TypeError as err:\n",
        "    # 輸出錯誤訊息\n",
        "    print(err)  \n",
        "    \n",
        "# 輸出 (1, 2, 3, 4, 5)\n",
        "print(t4)        "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8GNX_s_k4uE1"
      },
      "source": [
        "### 字典（Dictionary）"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tn2m17Qv537V"
      },
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": 248,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GAkIYCO-dz0e",
        "outputId": "98df8c7f-078a-4a6c-8cc1-405c967b68b6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{'a': 123, 'b': 'Hello World', 'c': True, 'd': [4, 5, 6], 'e': {'foo': 'bar'}}\n",
            "5\n",
            "123\n",
            "Hello World\n",
            "True\n",
            "4\n",
            "bar\n"
          ]
        }
      ],
      "source": [
        "# dict 結構型態\n",
        "\n",
        "# 宣告 dict 結構變數\n",
        "\n",
        "\n",
        "\n",
        "d1 = {\n",
        "    'a': 123,\n",
        "    'b': 'Hello World',\n",
        "    'c': True,\n",
        "    'd': [4, 5, 6],\n",
        "    'e': {'foo': 'bar'}\n",
        "}                     \n",
        "\n",
        "# 輸出 d1 的所有內容\n",
        "# {'a': 123, 'b': 'Hello World', 'c': True, 'd': [4, 5, 6], 'e': {'foo': 'bar'}}\n",
        "print(d1)             \n",
        "                      \n",
        "# 輸出 d1 的鍵值配對總數 5\n",
        "print(len(d1))        \n",
        "# 輸出 d1 中鍵為 'a' 的配對值 123\n",
        "print(d1['a'])        \n",
        "# 輸出 d1 中鍵為 'b' 的配對值 'Hello World'\n",
        "print(d1['b'])        \n",
        "# 輸出 d1 中鍵為 'c' 的配對值 True\n",
        "print(d1['c'])        \n",
        "# 輸出 d1 中鍵為 'd' 的配對值 list 當中，位置為 0 的值 4\n",
        "print(d1['d'][0])     \n",
        "# 輸出 d1 中鍵為 'e' 的配對值 dict 當中，鍵為 'foo' 的配對值 'bar'\n",
        "print(d1['e']['foo']) \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 249,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pmxis--pdz0f",
        "outputId": "59796e12-28f8-420e-9bcc-3b0dece8c49b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{'a': 'lala', 'b': 'Hello World', 'c': True, 'd': [4, 5, 6], 'e': {'foo': 'bar'}}\n"
          ]
        }
      ],
      "source": [
        "# 宣告 dict 結構變數\n",
        "d2 = {\n",
        "    'a': 123,\n",
        "    'b': 'Hello World',\n",
        "    'c': True,\n",
        "    'd': [4, 5, 6],\n",
        "    'e': {'foo': 'bar'}\n",
        "}                \n",
        "\n",
        "# 更改指定鍵的配對值\n",
        "d2['a'] = 'lala' \n",
        "# 輸出 {'a': 'lala', 'b': 'Hello World', 'c': True, 'd': [4, 5, 6], 'e': {'foo': 'bar'}}\n",
        "print(d2)        "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 250,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nyZTMT7qdz0f",
        "outputId": "e8816e6b-51f0-4cc6-e1b8-c070697de3ba"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{'a': 123, 'b': 'Hello World', 'c': True, 'd': [4, 5, 6], 'e': {'foo': 'bar'}, 'f': 123}\n"
          ]
        }
      ],
      "source": [
        "# 宣告 dict 結構變數\n",
        "d3 = {\n",
        "    'a': 123,\n",
        "    'b': 'Hello World',\n",
        "    'c': True,\n",
        "    'd': [4, 5, 6],\n",
        "    'e': {'foo': 'bar'}\n",
        "}             \n",
        "\n",
        "# 若對一個不存在的鍵賦與配對值，則創造一個新的鍵值配對\n",
        "d3['f'] = 123 \n",
        "# 輸出 {'a': 123, 'b': 'Hello World', 'c': True, 'd': [4, 5, 6], 'e': {'foo': 'bar'}, 'f': 123}\n",
        "print(d3)     "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 251,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sfdGnvZWdz0f",
        "outputId": "347295ac-bb32-40e1-f82b-50e612f1c96a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{'a': 123, 'b': 'Hello World', 'c': True, 'e': {'foo': 'bar'}}\n"
          ]
        }
      ],
      "source": [
        "# 宣告 dict 結構變數\n",
        "d4 = {\n",
        "    'a': 123,\n",
        "    'b': 'Hello World',\n",
        "    'c': True,\n",
        "    'd': [4, 5, 6],\n",
        "    'e': {'foo': 'bar'}\n",
        "}           \n",
        "\n",
        "# 使用 del 關鍵字可以刪除任意鍵值配對\n",
        "del d4['d'] \n",
        "# 輸出 {'a': 123, 'b': 'Hello World', 'c': True, 'e': {'foo': 'bar'}}\n",
        "print(d4)   "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 252,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bFZ6NGaJpixA",
        "outputId": "46134e02-db74-473d-b9c9-31878203803d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "dict_values([123, 'Hello World', True, {'foo': 'bar'}])\n",
            "dict_keys(['a', 'b', 'c', 'e'])\n",
            "dict_items([('a', 123), ('b', 'Hello World'), ('c', True), ('e', {'foo': 'bar'})])\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "[('a', 123), ('b', 'Hello World'), ('c', True), ('e', {'foo': 'bar'})]"
            ]
          },
          "execution_count": 252,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# 只取得 values \n",
        "print(d4.values())\n",
        "# 只取得 keys \n",
        "print(d4.keys())\n",
        "# 取得 key-value tuples \n",
        "print(d4.items())\n",
        "# 可以直接呼叫 list() 轉為 list 使用 \n",
        "list(d4.items())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PuyxCmVso4NB"
      },
      "source": [
        "### 補充：OrderedDict, 有序的 dictionary data structure \n",
        "  - [collections.OrderedDict](https://docs.python.org/3/library/collections.html#collections.OrderedDict)\n",
        "  - [Sorted Dict](https://grantjenks.com/docs/sortedcontainers/sorteddict.html)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 253,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cyI6KWswos80",
        "outputId": "9373740d-00b7-41b7-a22f-dc9b913a6aaa"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "OrderedDict([('zebra', 1), ('crocodile', 5), ('alligator', 3), ('monkey', 2), ('mamba', 10)])\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "OrderedDict([('alligator', 3),\n",
              "             ('crocodile', 5),\n",
              "             ('mamba', 10),\n",
              "             ('monkey', 2),\n",
              "             ('zebra', 1)])"
            ]
          },
          "execution_count": 253,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from collections import OrderedDict\n",
        "# 創建 empty OrderedDict \n",
        "animal_dict = OrderedDict()\n",
        "animal_dict['zebra'] = 1 \n",
        "animal_dict['crocodile'] = 5 \n",
        "animal_dict['alligator'] = 3\n",
        "animal_dict['monkey'] = 2 \n",
        "animal_dict['mamba'] = 10 \n",
        "# 會保持插入順序 \n",
        "# OrderedDict([('zebra', 1), ('crocodile', 5), ('alligator', 3), ('monkey', 2), ('mamba', 10)])\n",
        "print(animal_dict)\n",
        "\n",
        "\n",
        "# 如果想要整理一個既有的 dict，讓他按照自己喜歡的方式排序\n",
        "# 1. 先使用 sorted() 對既存的 dict 類別先進行排序\n",
        "# 2. 以下 `key = lambda x:x[0]` 為 anonymous function，指定以 key 的 ascii code 為 sort 順序（由小到大），可以定義自己的 sort function 替代\n",
        "# 3. 將其放入 OrderedDict()，這樣 key-value pairs 的擺放可維持 sort 後的順序\n",
        "# OrderedDict([('alligator', 3),\n",
        "#              ('crocodile', 5),\n",
        "#              ('mamba', 10),\n",
        "#              ('monkey', 2),\n",
        "#              ('zebra', 1)])\n",
        "animal_dict = {\n",
        "     'zebra': 1, \n",
        "     'crocodile': 5, \n",
        "     'alligator': 3, \n",
        "     'monkey': 2, \n",
        "     'mamba': 10, \n",
        "}\n",
        "sorted_animal = sorted(animal_dict.items(), key = lambda x:x[0])\n",
        "OrderedDict(sorted_animal)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gqrsKE57dz0f"
      },
      "source": [
        "## 條件判斷（Conditional Statement）\n",
        "\n",
        "### 條件運算子（Conditional Operator）\n",
        "\n",
        "|符號|名稱|範例|magic method|\n",
        "|-|-|-|-|\n",
        "|`==`|等於|`a == b`|`__eq__`|\n",
        "|`!=`|不等於|`a != b`|`_ne__`|\n",
        "|`<`|小於|`a < b`|`__lt__`|\n",
        "|`<=`|小於或等於|`a <= b`|`__le__`|\n",
        "|`>`|大於|`a > b`|`__gt__`|\n",
        "|`>=`|大於或等於|`a >= b`|`__ge__`|\n",
        "|`is`|相同記憶體位置|`a is b`|無法|\n",
        "|`in`|是否為成員|`a in b`|`__contains__`|\n",
        "\n",
        "- `a is b` 判斷 `a` 與 `b` 是否為相同的記憶體位置\n",
        "    - 與 C-like pointer 概念相同\n",
        "    - 當使用於數值型態資料時，其功能與 `==` 相同\n",
        "    - 當使用於非數值型態資料（如 `list`, `dict`, `tuple`, 任意型態的物件等）時，即 `id(a) == id(b)`\n",
        "- `a in b` 判斷 `a` 是否為 `b` 的成員\n",
        "    - 當 `b` 為字串時，用於檢查 `a` 是否為 `b` 的子字串\n",
        "    - 當 `b` 為 `dict` 時，用於檢查 `a` 是否為 `b` 的其中一個鍵（key）\n",
        "    - 當 `b` 為可列舉（iterable）的資料型態（如 `list`, `tuple`, `range` 等）時，用於檢查 `a` 是否為 `b` 的其中一個元素（element）\n",
        "\n",
        "### 邏輯運算子（Logical Operator）\n",
        "\n",
        "|符號|名稱|範例|\n",
        "|-|-|-|\n",
        "|`and`|且|`a and b`|\n",
        "|`or`|或|`a or b`|\n",
        "|`not`|非|`not a`|\n",
        "\n",
        "- 邏輯運算子的運算優先度為\n",
        "    1. `not`\n",
        "    2. `and`\n",
        "    3. `or`\n",
        "\n",
        "### 條件運算式 (Conditional Expression）\n",
        "\n",
        "- 由 1 個或多個條件運算子經由邏輯運算子所組合成的運算式即為條件運算式\n",
        "\n",
        "### `if` 語句\n",
        "\n",
        "- python 中的執行環境（block）\n",
        "    - 就如同大部分的指令式程式語言，python 在遇到 `if`、`while`、`for`、`def` 等語句時，會產生出新的執行環境\n",
        "    - 與 C-like 語言不同的是，python 並不使用 `{ }` 來宣告一個執行環境，而是直接使用**縮排**的數量（Indentation Level）來判斷\n",
        "    - 相鄰的兩行程式碼若有一樣的縮排數的話，會被視為在同一個執行環境裡面，享有一樣的變數存取範圍（scope）\n",
        "    - 常用的縮排為：2 個空白鍵、4 個空白鍵、1 個 tab 等\n",
        "    - 注意在同一個執行環境內必須使用相同的縮排，否則會出現錯誤：Indentation Error\n",
        "- 在 python 中最簡單的流程控制語句為 `if...else` 語句\n",
        "    - `if` 語句（注意縮排）僅在條件判斷式為 `True` 時執行 `if` 執行環境內的指令：\n",
        "    ```python\n",
        "    if condition:\n",
        "        some_statement # 當 condition 為 True 時執行 some_statement\n",
        "    ```\n",
        "    - 若要串接多個條件判斷式，可使用 `if...elif` 語句：\n",
        "    ```python\n",
        "    if condition_1:\n",
        "        some_statement_1 # 當 condition_1 為 True 時執行 some_statement_1\n",
        "    elif condition_2:\n",
        "        some_statement_2 # 當 condition_1 為 False\n",
        "                         # 且 condition_2 為 True 時執行 some_statement_2\n",
        "    elif condition_3:\n",
        "        some_statement_3 # 當 condition_1 與 condition_2 皆為 False\n",
        "                         # 且 condition_3 為 True 時執行 some_statement_3\n",
        "    ```\n",
        "    - 若列舉的條件以外有統一的處理方式，可使用 `if...else` 語句：\n",
        "    ```python\n",
        "    if condition:\n",
        "        some_statement_1 # 當 condition 為 True 時執行 some_statement_1\n",
        "    else:\n",
        "        some_statement_2 # 當 condition 為 False 時執行 some_statement_2\n",
        "    ```\n",
        "- 如果 `if` 語句後面只有一個指令要做的話，可以簡單的寫成一行：\n",
        "    ```python\n",
        "    if condition: expression\n",
        "    ```\n",
        "- 如果 `if...else` 語句，`if` 和 `else` 的後面都只有一個指令要做的話，可以簡單寫成一行：\n",
        "    ```python\n",
        "    expression_1 if condition else expression_2\n",
        "    ```\n",
        "    - 類似 C-like 語言當中的 `condition ? expression_1 : expression_2` 語句"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 254,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S5biOuwHdz0f",
        "outputId": "f0c62568-73b3-4b04-8c85-aaa9e8f83fe3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "False\n",
            "True\n",
            "True\n",
            "True\n",
            "False\n",
            "True\n"
          ]
        }
      ],
      "source": [
        "# 基本條件判斷\n",
        "# 因為 1 並非大於 3，輸出 False\n",
        "print(1 > 3)  \n",
        "# 因為 1 小於 3，輸出 True\n",
        "print(1 < 3)  \n",
        "# 因為 1 等於 1，輸出 True\n",
        "print(1 >= 1) \n",
        "# 因為 3 小於 5，輸出 True\n",
        "print(3 <= 5) \n",
        "# 因為 1 並非等於 0，輸出 False\n",
        "print(1 == 0) \n",
        "# 因為 2 不等於 3，輸出 True\n",
        "print(2 != 3) "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 255,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s_CqLnmkdz0f",
        "outputId": "8d15f38a-fbaa-4d45-e090-37dcb0dfeaa7"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n"
          ]
        }
      ],
      "source": [
        "# 用於字串比較時，照字典順序決定大小\n",
        "print('100' < '99')  \n",
        "# 由於 '1' 的 unicode 小於 '9'，輸出 True"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 256,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KniVaVoudz0f",
        "outputId": "b32ac480-ac81-4c43-f35d-4d75568aac2b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n",
            "False\n"
          ]
        }
      ],
      "source": [
        "# ==等號 與 is符號 比較.\n",
        "\n",
        "# ==: 依照物件內__eq__定義判斷\n",
        "a = {'a': 1, 'b': 2}\n",
        "# is: 判斷reference位置是否相同\n",
        "b = {'a': 1, 'b': 2}\n",
        "\n",
        "print(a == b)\n",
        "print(a is b)       # equal to => (id(a) == id(b))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 257,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8xqi-hM1dz0f",
        "outputId": "0997c1ec-cf1b-4d5f-ebb9-4c9143812db4"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n",
            "True\n",
            "True\n"
          ]
        }
      ],
      "source": [
        "# 成員運算子 in\n",
        "\n",
        "# 用於字串型態時，檢查是否為子字串\n",
        "print('ai' in 'bait') \n",
        "# 由於 ai 是 bait 的子字串，輸出 True\n",
        "\n",
        "l7 = [2, 3, 5, 7, 11]\n",
        "# 用於 list（iterable）時，檢查是否為 list 中的成員之一\n",
        "print(2 in l7)         \n",
        "# 由於 2 是 list l7 的第 1 個成員，輸出 True                       \n",
        "\n",
        "d5 = {1: 'a', 2: 'b', 3: 'c'}\n",
        "# 用於 dict 時，檢查是否為 dict 的其中一個 key\n",
        "print(1 in d5)         \n",
        "# 由於 1 是 dict d5 的 key，輸出 True                       "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 258,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8CBfFHTxdz0g",
        "outputId": "9556252e-09f4-421d-93d1-051cf4c31055"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n"
          ]
        }
      ],
      "source": [
        "# 邏輯運算優先順序  Not > and > True\n",
        "print(True or False and not True)       # t + f * -t\n",
        "# = (True or (False and (not True)))\n",
        "# = (True or (False and False))        \n",
        "# = (True or False)                                  \n",
        "# = True，輸出 True                                  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 259,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4KW_kY8Sdz0g",
        "outputId": "d8083e53-de95-48f7-cfeb-24913e800703"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1 > 0\n"
          ]
        }
      ],
      "source": [
        "# if 語句\n",
        "if 1 > 0:\n",
        "    # 輸出 1 > 0\n",
        "    print('1 > 0') "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 260,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2ZuI7abvdz0g",
        "outputId": "39792513-ac75-4931-c974-4a0d631f671e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "odd\n"
          ]
        }
      ],
      "source": [
        "# if else 語句\n",
        "if 5 % 2 == 0:\n",
        "    # 因為 5 為奇數，所以不輸出 even\n",
        "    print('even') \n",
        "else:\n",
        "    # 因為 5 為奇數，所以輸出 odd\n",
        "    print('odd')  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 261,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s8MPliSPdz0g",
        "outputId": "7f2cfe4f-02f1-422c-a88d-97b383d05a4e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "negative\n"
          ]
        }
      ],
      "source": [
        "# if elif else 語句\n",
        "b = -3\n",
        "if b > 0:\n",
        "    # 因為 -3 為負數，所以不輸出 positive\n",
        "    print('positive') \n",
        "elif b < 0:\n",
        "    # 因為 -3 為負數，所以輸出 negative，並跳過 else 語句\n",
        "    print('negative') \n",
        "else:\n",
        "    # 跳過不執行\n",
        "    print('zero')     "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 262,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ElBRkKB5ypy-",
        "outputId": "75b06593-23ed-4b51-91f2-5a781d7d06d9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "ai is in bait\n"
          ]
        }
      ],
      "source": [
        "# if 縮寫版本\n",
        "# `string` \n",
        "# 輸出 ai is in bait\n",
        "if 'ai' in 'bait': print('ai is in bait')          "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 263,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uk0EAmVqdz0g",
        "outputId": "c41561e8-1017-40df-ba3c-6c7df3f643c8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "No permission\n",
            "No permission\n"
          ]
        }
      ],
      "source": [
        "# if else 縮寫版本\n",
        "# `iterable datatype`\n",
        "# 輸出 No permission\n",
        "member = 'John'\n",
        "accepted_members = ['Jason', 'Mary', 'Claire']\n",
        "print('Hello') if member in accepted_members else print('No permission') \n",
        "\n",
        "# 上例條件判斷等同於：\n",
        "if member in accepted_members:\n",
        "    print('Hello') \n",
        "else:\n",
        "    print('No permission') \n",
        "# 語法上可以使用 「nested 縮寫 if else」，然而會使得程式碼可讀性下降、因此不建議兩層（含）以上的 if statement 改寫成縮寫版。"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 282,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Junior\n"
          ]
        }
      ],
      "source": [
        "year = 5\n",
        "if year < 4:\n",
        "    print('Graduated')\n",
        "elif 4 <= year <= 7: # 等同於 year >= 4 and year <= 7\n",
        "    if year == 7:\n",
        "        print('Freshman')\n",
        "    elif year == 6:\n",
        "        print('Sophomore')\n",
        "    elif year == 5:\n",
        "        print('Junior')\n",
        "    elif year == 4:\n",
        "        print('Senior')\n",
        "else:\n",
        "    print('Not Registered Yet')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y6WsDqSCdz0g"
      },
      "source": [
        "## 迴圈（Loop）\n",
        "\n",
        "### `for` 迴圈（For Loop、Iteration）\n",
        "\n",
        "- 與 `if` 語句相同皆須縮排\n",
        "- `for` 迴圈用途為依序取得序列裡的元素，並將元素指定給前面自訂的變數，再執行迴圈裡的內容\n",
        "    ```python\n",
        "    for variable in iterable:\n",
        "        some_statement # Do something\n",
        "    ```\n",
        "- `iterable` 可以為 `list`, `str`, `tuple`, `dict` 或是 `range` 函式\n",
        "    - `list`, `str`, `tuple` 會列舉每個位址中的值\n",
        "    - **`dict` 會列舉所有的鍵**\n",
        "    - `range` 是生成器（generator），會按照需求生成值直到滿足停止條件\n",
        "- `range` 函式\n",
        "    - 是一種生成器（generator）\n",
        "    - start 為起始值，end 為中止值(不包含)，step 為遞增(減)值 (非必要)\n",
        "    ```python\n",
        "    range(start)\n",
        "    range(start, end)\n",
        "    range(start, end, step)\n",
        "    ```\n",
        "    \n",
        "### 巢狀迴圈  (Nested Loop)\n",
        "\n",
        "- 若迴圈內容受到兩個 (或兩個以上) 的變數來分別控制其變化，此時可使用巢狀迴圈\n",
        "    ```python\n",
        "    for variable_1 in iterable_1:\n",
        "        some_statement_1 # Do something\n",
        "        for variable_2 in iterable_2:\n",
        "            some_statement_2 # Do something\n",
        "    ```\n",
        "\n",
        "### `while` 迴圈（While Loop）\n",
        "\n",
        "- 與 `if` `for` 語句相同皆須縮排\n",
        "- `while` 迴圈用途為在指定條件下，重複執行迴圈裡的內容，直到不再滿足條件為止\n",
        "    ```python\n",
        "    while condition:\n",
        "        some_statement # Do something\n",
        "    ```\n",
        "- `while` 迴圈為先計算是否滿足條件，若滿足再執行迴圈內容\n",
        "\n",
        "### `break`, `continue`  語句（Flow Control）\n",
        "\n",
        "- `break` 用途為中斷迴圈的執行並**跳脫迴圈**，繼續執行迴圈外的敘述\n",
        "- `continue` 用途為跳過迴圈內 `continue` 後面的剩餘敘述，接著繼續執行下一次的迴圈運作，**不會跳脫迴圈**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 283,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cXYOtuFGdz0g",
        "outputId": "91d079f1-f5c8-476b-83af-0eb9ff8c7670"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "P y t h o n \n",
            "----------\n",
            "2\n",
            "4\n",
            "6\n",
            "8\n",
            "10\n",
            "----------\n",
            "a:123\n",
            "b:456\n",
            "----------\n",
            "a:123\n",
            "b:456\n"
          ]
        }
      ],
      "source": [
        "# for 迴圈\n",
        "\n",
        "# 依序取得 list 內的所有元素\n",
        "# 依序取出 [1, 2, 3] 內所有值，並指定給 element\n",
        "for element in [1, 2, 3]:        \n",
        "    # 將 element 輸出，每一輸出皆會換行\n",
        "    print(element)               \n",
        "    \n",
        "# 依序輸出 str 中的所有字元 (char)\n",
        "# 依序取出 Python 所有字元，並指定給 character\n",
        "for character in 'Python':     \n",
        "    # 用 end 指定每一輸出最後加上空白，而非換行符號  \n",
        "    print(character, end=' ')  \n",
        "# 輸出換行符號\n",
        "print()                    \n",
        "print('-'*10)\n",
        "# 依序取得 tuple 內的所有元素\n",
        "# 依序取出 (1, 2, 3, 4, 5) 內所有元素，並指定給 element\n",
        "for element in (1, 2, 3, 4, 5):  \n",
        "    # 將 element * 2 後再輸出，每一輸出皆會換行\n",
        "    print(element * 2)           \n",
        "print('-'*10)   \n",
        "# 依序取得 dict 內的所有元素\n",
        "d6 = {'a': 123, 'b': 456}\n",
        "# 依序取出 {'a': 123, 'b': 456} 內所有鍵，並指定給 key\n",
        "for key in d6:                   \n",
        "    # 用 sep 指定輸出值之間的分隔字元為『:』，而非空白\n",
        "    print(key, d6[key], sep=':')\n",
        "print('-'*10)\n",
        "# 依序取得 dict 內的所有元素 (2)\n",
        "# 使用 .items() 來一次獲取 key-value pairs \n",
        "for key, value in d6.items():\n",
        "    print(key, value, sep=':') "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 284,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U4jXcQ3qdz0g",
        "outputId": "4b59c96c-0a41-4844-c424-f3831891637a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "6\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "execution_count": 284,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "start = -1\n",
        "end = 10\n",
        "step = 2\n",
        "print((end-start-1)//step + 1)\n",
        "len(range(start, end, step)) "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 285,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IAx8f7l8dz0g",
        "outputId": "855c6d7f-ec84-46d0-fc24-f6ec28ec4912"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "0 1 2 3 4 5 6 7 8 9 \n",
            "8 6 4 2 0 -2 -4 -6 \n",
            "1995 10 12 \n",
            "|2x1= 2|2x2= 4|2x3= 6|2x4= 8|2x5=10|2x6=12|2x7=14|2x8=16|2x9=18|\n",
            "|3x1= 3|3x2= 6|3x3= 9|3x4=12|3x5=15|3x6=18|3x7=21|3x8=24|3x9=27|\n",
            "|4x1= 4|4x2= 8|4x3=12|4x4=16|4x5=20|4x6=24|4x7=28|4x8=32|4x9=36|\n",
            "|5x1= 5|5x2=10|5x3=15|5x4=20|5x5=25|5x6=30|5x7=35|5x8=40|5x9=45|\n",
            "|6x1= 6|6x2=12|6x3=18|6x4=24|6x5=30|6x6=36|6x7=42|6x8=48|6x9=54|\n",
            "|7x1= 7|7x2=14|7x3=21|7x4=28|7x5=35|7x6=42|7x7=49|7x8=56|7x9=63|\n",
            "|8x1= 8|8x2=16|8x3=24|8x4=32|8x5=40|8x6=48|8x7=56|8x8=64|8x9=72|\n",
            "|9x1= 9|9x2=18|9x3=27|9x4=36|9x5=45|9x6=54|9x7=63|9x8=72|9x9=81|\n"
          ]
        }
      ],
      "source": [
        "# range 函式\n",
        "# int result[(end - start) / step + 1];\n",
        "# for (int v=start; v<end; v+=step) {\n",
        "#   result[i] = v;\n",
        "# }\n",
        "\n",
        "# 創建起始為 0 中止為 9 的整數 list，並依序印出\n",
        "for number in range(10):        \n",
        "    print(number, end=' ')\n",
        "print()\n",
        "\n",
        "# 創建起始為 8 中止為 -8 且遞減值為 2 的整數 list，並依序印出\n",
        "for number in range(8, -8, -2): \n",
        "    print(number, end=' ')\n",
        "print()\n",
        "\n",
        "l8 = [1995, 10, 12] # (L8)\n",
        "# 創建起始為 0 中止為 len(l8) = 3 的整數 list，名為 l8\n",
        "for index in range(len(l8)):    \n",
        "    # 依序印出名為 l8  的 list 中第 index 個位置的值\n",
        "    print(l8 [index], end = ' ') \n",
        "print()\n",
        "\n",
        "# 巢狀迴圈九九乘法表\n",
        "for number1 in range(2, 10, 1):\n",
        "    print('|', end='')\n",
        "    for number2 in range(1, 10, 1):\n",
        "        print('{}x{}={:2d}'.format(number1, number2, number1 * number2), end='|')\n",
        "    print()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 286,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HS9yHhI_dz0g",
        "outputId": "cf58c7a9-323c-4464-faf7-b8bb31be62ea"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "0 1 2 3 4 5 6 7 8 9 \n",
            "Sum 1 to 10 is 55\n",
            "|2x1= 2|2x2= 4|2x3= 6|2x4= 8|2x5=10|2x6=12|2x7=14|2x8=16|2x9=18|\n",
            "|3x1= 3|3x2= 6|3x3= 9|3x4=12|3x5=15|3x6=18|3x7=21|3x8=24|3x9=27|\n",
            "|4x1= 4|4x2= 8|4x3=12|4x4=16|4x5=20|4x6=24|4x7=28|4x8=32|4x9=36|\n",
            "|5x1= 5|5x2=10|5x3=15|5x4=20|5x5=25|5x6=30|5x7=35|5x8=40|5x9=45|\n",
            "|6x1= 6|6x2=12|6x3=18|6x4=24|6x5=30|6x6=36|6x7=42|6x8=48|6x9=54|\n",
            "|7x1= 7|7x2=14|7x3=21|7x4=28|7x5=35|7x6=42|7x7=49|7x8=56|7x9=63|\n",
            "|8x1= 8|8x2=16|8x3=24|8x4=32|8x5=40|8x6=48|8x7=56|8x8=64|8x9=72|\n",
            "|9x1= 9|9x2=18|9x3=27|9x4=36|9x5=45|9x6=54|9x7=63|9x8=72|9x9=81|\n"
          ]
        }
      ],
      "source": [
        "# while 迴圈\n",
        "\n",
        "# 宣告 count 為 0\n",
        "count = 0                   \n",
        "# 若滿足條件 count < 10，則執行迴圈內容\n",
        "while count < 10:           \n",
        "    # 輸出 count\n",
        "    print(count, end = ' ') \n",
        "    # 將 count 加 1，避免陷入無窮迴圈\n",
        "    count = count + 1       \n",
        "print()\n",
        "\n",
        "# 用 while loop 計算 1 到 10 的總和\n",
        "total_count = 0\n",
        "count = 1\n",
        "while count <= 10:\n",
        "    total_count = total_count + count\n",
        "    count = count + 1\n",
        "print('Sum 1 to 10 is', total_count)\n",
        "\n",
        "# nested while loop example: 九九乘法表\n",
        "number1 = 2\n",
        "while number1 < 10:\n",
        "    print('|', end='')\n",
        "    number2 = 1\n",
        "    while number2 < 10:\n",
        "        print(\"{}x{}={:2d}\".format(number1, number2, number1 * number2), end='|')\n",
        "        number2 = number2 + 1\n",
        "    number1 = number1 + 1\n",
        "    print()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 287,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gttBcFofdz0g",
        "outputId": "fd56a5c8-6f8a-4a1f-9193-0ddb24de8bd0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "to\n",
            "toay is Wenesay."
          ]
        }
      ],
      "source": [
        "# break, continue 語句\n",
        "\n",
        "# break 語句\n",
        "for character in 'today is Wednesday.':\n",
        "    # 若 character 為 d 則跳脫迴圈，不再執行迴圈內容\n",
        "    if character == 'd': \n",
        "        break\n",
        "    print(character, end='')\n",
        "print()\n",
        "\n",
        "# continue 語句\n",
        "for character in 'today is Wednesday.':\n",
        "    # 若 character 為 d 則不再執行 continue 後的內容(不輸出 char)，繼續執行迴圈\n",
        "    if character == 'd': \n",
        "        continue\n",
        "    print(character, end='')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RVQjYiYGdz0g"
      },
      "source": [
        "## 函數（Function）\n",
        "\n",
        "在之前的教學中，我們已經碰過許多**函數（function）**，包含 `print()` `range()` 等都屬於函數，為內建函數（built-in functions）。\n",
        "而我們也可以自行定義函數，可將程式中重複出現的程式碼寫成函數，往後只要直接呼叫該函數即可，省下大量書寫重複程式碼的力氣並增加可讀性。\n",
        "\n",
        "### 定義函數（Function Definition）\n",
        "\n",
        "定義函數使用關鍵字 `def`，其後空一格接**函數名稱**與**小括弧**，小括弧用來放**參數**列（Parameter List）\n",
        "\n",
        "- 函數內容與 `if`, `for` 語句相同皆須**縮排**\n",
        "- 函數可用 `return` 設定回傳值（Return Value），並可回傳多個數值\n",
        "\n",
        "```python\n",
        "def function_name(parameter1, parameter2, more_parameters):\n",
        "    some_statement # Do something\n",
        "    return some_value\n",
        "```\n",
        "    \n",
        "### 呼叫函數（Function Call）\n",
        "\n",
        "打上函數名稱，其後接小括弧，小括弧用來放**引數**列（Argument List），即完成函數的呼叫。\n",
        "\n",
        "```python\n",
        "function_name(argument1, argument2, more_arguments)\n",
        "```\n",
        "如果沒有引數要被傳入，則使用 \n",
        "```python\n",
        "function_name()\n",
        "``` \n",
        "呼叫。"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 288,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qN3B0xjAdz0h",
        "outputId": "80ed5c10-8ce3-45a6-a4cf-70ddcddc8c55"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Happy birthday to Alice\n",
            "Happy birthday to Bob\n",
            "Happy birthday to Carlie\n",
            "Happy birthday to Daniel\n"
          ]
        }
      ],
      "source": [
        "# 函數\n",
        "\n",
        "# 定義函數\n",
        "# 定義一個函數，名稱為 happy_birthday，參數為 name\n",
        "def happy_birthday(name: str) -> None:            \n",
        "    # 輸出 Happy birthday to 加上參數 name\n",
        "    print(f'Happy birthday to {name}') \n",
        "    # 設定回傳值為空\n",
        "    return                            \n",
        "\n",
        "# 呼叫函數\n",
        "for person in ['Alice', 'Bob', 'Carlie', 'Daniel']:\n",
        "    # 呼叫函數 happy_birthday，引數為 person\n",
        "    happy_birthday(person)           "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "19tHfy_Zdz0h"
      },
      "source": [
        "### 函數的引數（Arguments）\n",
        "\n",
        "函數可以使用以下三種引數：\n",
        "\n",
        "- **位置引數（Positional Arguments）**\n",
        "    - 引數的順序和個數必須與函數的順序和個數相同\n",
        "- **關鍵字引數（Keyword Arguments）**\n",
        "    - 可指定引數給參數使用，引數與參數順序不必相同\n",
        "-  **預設引數**\n",
        "    - 可以在定義函數時，給予參數預設值，若呼叫函數時沒有給予引數，則會使用預設值"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 289,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ld_4mr7fdz0h",
        "outputId": "dfd56563-d14a-4369-84ab-d0c725b8aa68"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "happy_birthday() missing 1 required positional argument: 'name'\n"
          ]
        }
      ],
      "source": [
        "# 必選引數\n",
        "try:\n",
        "    # 呼叫函數 happy birthday，因為少給一個必選引數 name，因此發生 error\n",
        "    # happy_birthday() missing 1 required positional argument: 'name'\n",
        "    happy_birthday() \n",
        "\n",
        "except TypeError as err:\n",
        "    # 輸出錯誤訊息\n",
        "    print(err)       "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 290,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RDEOURSFdz0h",
        "outputId": "f53ea77e-c5ab-4dac-9a9c-a0e1f93cfad9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Hi, Alice\n",
            "Your BMI is 18.426534209261334\n",
            "Hi, Bob\n",
            "Your BMI is 23.889462809917354\n"
          ]
        }
      ],
      "source": [
        "# 宣告 dict 結構變數\n",
        "BMI_list = [\n",
        "    {'name': 'Alice', 'height': 1.58, 'weight': 46},\n",
        "    {'name': 'Bob', 'height': 1.76, 'weight': 74}\n",
        "] \n",
        "\n",
        "# 有寫 typing 的例子！\n",
        "# 定義一個函數，名稱為 BMI，參數為 height, weight\n",
        "def BMI(height: float, weight: float) -> float:             \n",
        "    # 回傳 BMI 值\n",
        "    return weight / (height ** 2)    \n",
        "\n",
        "\n",
        "\n",
        "for data in BMI_list:\n",
        "    print(f\"Hi, {data['name']}\")\n",
        "    print('Your BMI is {}'.format(\n",
        "        # 使用關鍵字指定引數\n",
        "        # 呼叫函數 BMI，每個引數皆指定參數名稱，因此引數順序可不必與參數相同\n",
        "        BMI(weight=data['weight'],\n",
        "            height=data['height'])\n",
        "    ))\n",
        "    # 使用位置引數的話，每個引數的順序要正確\n",
        "    #    BMI(data['height'],\n",
        "    #         data['weight'])\n",
        "    # ))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 291,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p9BasIZ-dz0h",
        "outputId": "c892b2b0-f792-4c4b-eb80-f767e72bccb3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Hi, Alice\n",
            "Your BMI is 20.028841531805796\n",
            "Hi, Bob\n",
            "Your BMI is 16.141528925619834\n"
          ]
        }
      ],
      "source": [
        "# 預設引數\n",
        "\n",
        "# 宣告 dict 結構變數\n",
        "BMI_list = [\n",
        "    {'name': 'Alice', 'height': 1.58, 'weight': 46},\n",
        "    {'name': 'Bob', 'height': 1.76, 'weight': 74}\n",
        "] \n",
        "\n",
        "# 定義一個函數，名稱為 BMI，參數為 height, weight\n",
        "def BMI(height: float, weight: float) -> float:            \n",
        "    # 回傳 BMI\n",
        "    return weight / (height ** 2)   \n",
        "\n",
        "# 定義一個函數，名稱為 BMI_default，給定參數 weight 的預設值 50\n",
        "def BMI_default(height: float, weight: float = 50) -> float: \n",
        "    return BMI(height, weight)\n",
        "\n",
        "for data in BMI_list:\n",
        "    print('Hi, {}'.format(data['name']))\n",
        "    # 呼叫函數 BMI_default\n",
        "    # 因參數 weight 有預設值，因此可不必給 weight 數值\n",
        "    print('Your BMI is {}'.format(\n",
        "        BMI_default(data['height']) \n",
        "    ))                              "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### 參數傳遞方式 (Parameter Passing)\n",
        "- Pass by Value: 此種傳遞方式會在函數內另起一個新變數, 並將 caller 傳入的引數值 `x` 複製一份新的傳入這個新變數, 意即新變數會指涉到這個複製的 value, **行為上你在函數（local）內對 `x` 做任何修改，對外部（global）的 `x` 都不會有影響**。如 C-like 語言中直接傳值。\n",
        "- Pass by Reference: 傳入的是位址，行為上你在函數（local）內對 `x` 做任何修改，**都會反映在外部（global）的 `x` 上**。如 C-like 語言中可以使用 pointer 來達到這個效果。\n",
        "- Pass by Object Reference / Call by Sharing:\n",
        "此方式會在函數中製造一個新的變數, 但是傳入的值卻不會複製, 而是讓裡面的新 variable 指涉到一樣的值。\n",
        "\n",
        "-  `Python` 使用的是 Pass by Object Reference / Call by Sharing，\n",
        "  - 如果傳入的參數為**不可變的資料型態**（int, float, str, tuple）變數，則在函數中改變了參數的值**不會**影響到原本傳入的引數。\n",
        "  - 如果傳入的參數為**可變的資料型態**（list, dict, set, ...）變數，則在函數中 manipulate 結構內的元素**會**影響到原本傳入的引數。\n",
        "  - 即使是可變的資料型態，重新在函數內將引數 assign （=）成其他值，**不會** 改變外界引數內原本的值。\n",
        "  - 以上講的都是「沒有回傳(return) 並 reassign」的情況。"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 515,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nEu11JFjEeft",
        "outputId": "13da82a8-1f41-4ed0-8177-7126a0ae1532"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "inside change_num: 3\n",
            "outside (global): 4\n"
          ]
        }
      ],
      "source": [
        "import functools\n",
        "def logme(f):\n",
        "    @functools.wraps(f)\n",
        "    def wrapped(*args, **kwargs):\n",
        "        print(f'inside {f.__name__}:', end = ' ')\n",
        "        return f(*args, **kwargs)\n",
        "    return wrapped\n",
        "\n",
        "# 數值型態\n",
        "x = 4 \n",
        "\n",
        "@logme\n",
        "def change_num(x:int)-> None:\n",
        "    x = 3 \n",
        "    print(x)\n",
        "    \n",
        "\n",
        "change_num(x)\n",
        "print(f'outside (global):', x)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 516,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fIvu_hPodz0h",
        "outputId": "717e2093-f18f-4e9d-9f8f-698f8ee2289d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "before change_dict: {'rewrite': 'no'}\n",
            "after change_dict: {'rewrite': 'yes'}\n"
          ]
        }
      ],
      "source": [
        "# 結構型態\n",
        "from typing import Dict\n",
        "\n",
        "# 宣告 dict 結構變數 (mutable object)\n",
        "d7 = {'rewrite': 'no'}               \n",
        "\n",
        "# 定義一個函數，名稱為 change_dict，參數為 argument_dict\n",
        "def change_dict(argument_dict: Dict[str, str]) -> None:      \n",
        "    # 更改參數 argument_dict 的內容，即更改引數 d7 的內容\n",
        "    argument_dict['rewrite'] = 'yes' \n",
        "\n",
        "\n",
        "# 輸出更改前的結果\n",
        "print(f'before change_dict: {d7}')\n",
        "\n",
        "# 呼叫函數 change_dict\n",
        "change_dict(d7)                      \n",
        "\n",
        "# 輸出外界的結果：\n",
        "print(f'after change_dict: {d7}')\n",
        "# 與原本宣告的 d7 內容不同。                        "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 552,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9xoF4OEdHLVo",
        "outputId": "7b5c5428-0370-4ae9-909b-c3a2a1dabbf9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "before reassign_dict: {'rewrite': 'no'}\n",
            "after reassign_dict: {'rewrite': 'no'}\n"
          ]
        }
      ],
      "source": [
        "# 結構型態，使用 reassign \n",
        "from typing import Dict\n",
        "\n",
        "# 宣告 dict 結構變數 (mutable object)\n",
        "d_ = {'rewrite': 'no'}               \n",
        "\n",
        "# 定義一個函數，名稱為 reasssign_dict，參數為 argument_dict\n",
        "def reassign_dict(argument_dict: Dict[str, str]) -> None:      \n",
        "    # 更改參數 argument_dict 的內容，即更改引數 d7 的內容\n",
        "    argument_dict = {'wow': 'totally different'}\n",
        "\n",
        "\n",
        "\n",
        "# 輸出更改前的結果\n",
        "print(f'before reassign_dict: {d_}')\n",
        "\n",
        "# 呼叫函數 reassign\n",
        "reassign_dict(d_)                      \n",
        "\n",
        "# 輸出外界的結果：\n",
        "print(f'after reassign_dict: {d_}')\n",
        "# 與原本宣告的 d_ 內容不同。  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZDeM_sDkT9vn",
        "outputId": "83940d71-fefb-4deb-9918-96e592bdce05"
      },
      "outputs": [],
      "source": [
        "## 思考1：下例的輸出為何？\n",
        "\n",
        "def foo(lst):\n",
        "  lst.append(1)       \n",
        "  lst = [2]         \n",
        "m = []\n",
        "foo(m)\n",
        "print(m)\n",
        "\n",
        "# (A) [1]\n",
        "# (B) [2]\n",
        "# (C) []"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dkjlBlC6UsHn",
        "outputId": "da11da6f-c4cc-482b-b0c3-9f5078d3d1b2"
      },
      "outputs": [],
      "source": [
        "## 思考2：下例的輸出為何？\n",
        "def foo(lst):\n",
        "  lst.append(1)       \n",
        "  lst = [2]         \n",
        "  return lst       \n",
        "m = [] \n",
        "m = foo(m)         \n",
        "print(m)\n",
        "\n",
        "# (A) [1]\n",
        "# (B) [2]\n",
        "# (C) []"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fTuYn7gzWNiK"
      },
      "source": [
        "- **進階使用**\n",
        "    - positional-only: 定義在`/`之前的參數，`/` 容許該 parameter name 之後被修改也不會造成舊的程式碼呼叫問題。 \n",
        "    - positional-or-keyword: 定義在`/`之後、`*`之前的參數\n",
        "    - var-positional: 使用`*args`指定的參數\n",
        "    - keyword-only: 在`*`之後的參數\n",
        "    - var-keyword: 使用`**kwargs`指定的參數\n",
        "      "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 690,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(1, 4, 5, 7)\n",
            "{'h': 100}\n"
          ]
        }
      ],
      "source": [
        "def func(*args, **kwargs):\n",
        "  print(args)\n",
        "  print(kwargs)\n",
        "\n",
        "func(1, 4, 5, 7, h=100)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 691,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-d9-WMDvdxlH",
        "outputId": "516bcdca-a744-4028-b1c9-37f085f7902f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3.8.16\n"
          ]
        }
      ],
      "source": [
        "# slash arguments 在 Python 3.8 後被引入 \n",
        "import platform\n",
        "print(platform.python_version())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 692,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1\n",
            "2.5\n",
            "3\n",
            "4\n",
            "5.5\n",
            "----------\n",
            "func() got some positional-only arguments passed as keyword arguments: 'a, b'\n",
            "----------\n",
            "func() got some positional-only arguments passed as keyword arguments: 'a'\n"
          ]
        }
      ],
      "source": [
        "# 進階使用\n",
        "def func(a, b=2, /, c=3, *, d, e=5):\n",
        "    # a: positional-only，必須傳入, 順序性, 不可關鍵字傳入（因為 / 在前的緣故）\n",
        "    # b: positional-only，選擇傳入（因為有 default 值）, 順序性, 不可關鍵字傳入（因為 / 在前的緣故）\n",
        "    # c: positional-or-keyword，選擇傳入（因為有 default 值）, 非順序性, 可關鍵字傳入（因為 / 在後的緣故）\n",
        "    # d: keyword-only，必須傳入, 非順序性, 必須關鍵字傳入（因為 * 在後的緣故）\n",
        "    # e: keyword-only，選擇傳入, 非順序性, 可關鍵字傳入（因為 * 在後的緣故）\n",
        "    print('\\n'.join(map(str, [a, b, c, d, e])))\n",
        "    print('-'*10)\n",
        "\n",
        "# a = 1, b = 2.5, c = 3, d = 4, e = 5.5\n",
        "func(1, 2.5, d=4, e=5.5)\n",
        "\n",
        "# a 跟 b 都是 positional-only，因此不能用關鍵字傳入，會發生錯誤\n",
        "try:\n",
        "  func(a=1, b=2.5, d=4, e=5.5)\n",
        "except Exception as e:\n",
        "  print(e)\n",
        "\n",
        "print('-'*10)\n",
        "\n",
        "# 沒有傳入 b，因為 b 有 default 值，因此會維持 default 值 2\n",
        "# a 為 positional-only，因此不能用關鍵字傳入，所以報錯\n",
        "try:\n",
        "  func(a=1, d=4, e=5.5)\n",
        "except Exception as e:\n",
        "  print(e)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 693,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YxGdmiy3dz0h",
        "outputId": "c8a22279-64f5-4f2c-8391-e69601418a61"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1\n",
            "2.5\n",
            "3\n",
            "4\n",
            "5.5\n",
            "{'g': 1000}\n",
            "----------\n",
            "1\n",
            "2\n",
            "9\n",
            "4\n",
            "5.5\n",
            "{'b': 2.5, 'g': 1000}\n",
            "----------\n",
            "func2() missing 1 required positional argument: 'a'\n"
          ]
        }
      ],
      "source": [
        "# 進階使用\n",
        "def func2(a, b=2, /, c=3, *, d, e=5, **kwargs):\n",
        "    # a: positional-only，必須傳入, 順序性, 不可關鍵字傳入（因為 / 在前的緣故）\n",
        "    # b: positional-only，選擇傳入（因為有 default 值）, 順序性, 不可關鍵字傳入（因為 / 在前的緣故）\n",
        "    # c: positional-or-keyword，選擇傳入（因為有 default 值）, 非順序性, 可關鍵字傳入（因為 / 在後的緣故）\n",
        "    # d: keyword-only，必須傳入, 非順序性, 必須關鍵字傳入（因為 * 在後的緣故）\n",
        "    # e: keyword-only，選擇傳入, 非順序性, 可關鍵字傳入（因為 * 在後的緣故）\n",
        "    # **kwargs: var-keyword，選擇傳入, 非順序性, 接收其他未定義在函數內的 keyword arguments\n",
        "    print('\\n'.join(map(str, [a, b, c, d, e, kwargs])))  \n",
        "    print('-'*10)\n",
        "\n",
        "func2(1, 2.5, d=4, e=5.5, g=1000)\n",
        "\n",
        "# 只將 b 傳入 keyword args: 不會報錯，但會有令人意外的結果\n",
        "# `b` will NOT be assigned 2.5, and will go into **kwargs\n",
        "func2(1, b=2.5, c=9, d=4, e=5.5, g=1000)\n",
        "\n",
        "# 觀察錯誤訊息： 由於 a 跟 b 雖然都是 positional-only，但 b 有 default 值\n",
        "# 因此傳進去的 b=2.5 被當成是 var-keyword 的一部分，原本參數的 b 維持原本 default 值 2\n",
        "# 因此錯誤訊息只會報錯 a 沒有給值\n",
        "try:\n",
        "  func2(a=1, b=2.5, c=9, d=4, e=5.5, g=1000)\n",
        "except Exception as e:\n",
        "  print(e)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 694,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RDk_dJTiZhwi",
        "outputId": "5d313de6-6028-425f-eccf-8ec19a2f6969"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2\n",
            "4\n",
            "9\n",
            "11\n",
            "5\n",
            "{'h': 20, 'g': 30}\n",
            "----------\n",
            "2\n",
            "4\n",
            "9\n",
            "11\n",
            "5\n",
            "{'h': 20, 'g': 30}\n",
            "----------\n",
            "2\n",
            "4\n",
            "9\n",
            "11\n",
            "5\n",
            "{'g': 30, 'h': 20}\n",
            "----------\n"
          ]
        }
      ],
      "source": [
        "# 想要在函數裡得到 （positional）a = 2, （positional）b = 4, c = 9, d = 11, e = 5, g = 30, h = 20\n",
        "\n",
        "# 參考寫法：\n",
        "func2(2, 4, c=9, d=11, e=5, h=20, g=30)\n",
        "# c arg 可以選擇直接寫 9，不用 keyword 傳入\n",
        "func2(2, 4, 9, d=11, e=5, h=20, g=30)\n",
        "# h, g args 位置可以互換\n",
        "func2(2, 4, c=9, e=5, d=11, g=30, h=20)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yZWLwFH5dz0h"
      },
      "source": [
        "\n",
        "### 匿名函數（Anonymous Function）\n",
        "\n",
        "若函數只需要短暫利用便丟棄，那麼額外創造新的函數時可以選擇使用匿名函數\n",
        "\n",
        "- 匿名函數**沒有名稱**，不會「汙染」當前命名空間（Namespace）\n",
        "- 只能有一行運算式\n",
        "- 為**單純函數（Pure Function）**，不會在函數內部中產生**副作用（Side Effect）**\n",
        "  - Pure Function: 將相同的輸入丟入，永遠都會回傳相同的輸出，並且不對任何該函數以外的任何作用域產生影響。\n",
        "- 會**自動回傳**運算式的結果\n",
        "- 使用`lambda`保留字\n",
        "    ```python\n",
        "    lambda *args, **kwargs: ...\n",
        "    ```\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 695,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3\n",
            "3\n"
          ]
        }
      ],
      "source": [
        "def add(x, y):\n",
        "    return x + y\n",
        "\n",
        "a = add(1,2)\n",
        "print(a)    # 3\n",
        "\n",
        "# 改使用匿名函數寫法，會自動回傳 x + y 結果，不用再寫 return\n",
        "b = (lambda x, y: x + y)(1, 2)\n",
        "print(b)    # 3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 696,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pJELRI7-dz0i",
        "outputId": "5be232eb-7277-492e-8069-5cb2bd447a61"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "sorted(d8)=['a', 'b', 'c', 'd']\n",
            "d8_sorted=['d', 'a', 'c', 'b']\n",
            "d8_sorted=['d', 'a', 'c', 'b']\n",
            "d8_pairs_sorted=[('d', 1), ('a', 2), ('c', 3), ('b', 4)]\n"
          ]
        }
      ],
      "source": [
        "# 匿名函數\n",
        "\n",
        "# 宣告 dict 結構變數\n",
        "d8 = { \n",
        "    'a': 2,\n",
        "    'b': 4,\n",
        "    'c': 3,\n",
        "    'd': 1\n",
        "}\n",
        "\n",
        "# 排序 dict d8\n",
        "# 預設使用 d8 的鍵值(key)進行排序 # lexicographical order \n",
        "print(f\"{sorted(d8)=}\")\n",
        "                            \n",
        "\n",
        "# 排序 dict d8\n",
        "# 使用匿名函數(lambda)取出 d8 中的配對值(value)\n",
        "# 並改用配對值進行比較大小\n",
        "d8_sorted = sorted(d8, key=lambda x: d8[x])\n",
        "print(f\"{d8_sorted=}\")\n",
        "# 等價於: \n",
        "d8_sorted = sorted(d8, key=d8.get)\n",
        "print(f\"{d8_sorted=}\")\n",
        "\n",
        "# 如果要一次排序 d8 內的 key-value pairs，同上使用 value 做大小排序，可以使用 \n",
        "d8_pairs_sorted = sorted(d8.items(), key=lambda x:x[1])\n",
        "print(f\"{d8_pairs_sorted=}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8S6dba7Vdz0i"
      },
      "source": [
        "\n",
        "### 裝飾器 (Decorator)\n",
        "\n",
        "> 接受其他函數作為引數的函數\n",
        "\n",
        "```python\n",
        "# 定義 decorator\n",
        "def decorator(func):\n",
        "    def wrapper(*args, **kwargs):\n",
        "        ...\n",
        "        func(*args, **kwargs)\n",
        "        ...\n",
        "    return wrapper\n",
        "\n",
        "# 使用 decorator\n",
        "decoracted_func = decoractor(original_func)\n",
        "decoracted_func(*args, **kwargs)\n",
        "```\n",
        "- 用於執行引數函數前/後執行特定功能\n",
        "- 可使用@語法糖(syntax sugar)略過函數傳參過程"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MCUi4Ua4i3eY"
      },
      "source": [
        "#### 情境（scenario）\n",
        "公司有一個獲取 admin 密碼的函數，叫做 `get_admin_password()`。"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 697,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "BjEot-GFitvl",
        "outputId": "283f5a6b-8960-4029-e9c5-29a874ad7919"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'1234'"
            ]
          },
          "execution_count": 697,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Without decorators \n",
        "user = {'access_level': 'admin'}\n",
        "# 想要保護 admin 的密碼，不被 admin 以下等級者獲取\n",
        "def get_admin_password():\n",
        "    if user['access_level'] == 'admin':\n",
        "        return \"1234\"\n",
        "    else:\n",
        "        return f\"No permission for {user['access_level']} users\"\n",
        "get_admin_password() "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vjHwR9wKjsuP"
      },
      "source": [
        "假如我們有 `get_admin_account()`，`get_admin_private_info()` 之類的更多類似函數，難道每一個函數內都要寫一行保護用的 `if user['access_level'] == 'admin':` 判斷式嗎？"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 698,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "gDoAOZY-jroP",
        "outputId": "5ae5e1b9-652d-4a03-eb63-b6ca04a2bd1d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'1234'"
            ]
          },
          "execution_count": 698,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# decorator: basic level \n",
        "# 先將單純的 get_admin_password() 獨立出來\n",
        "\n",
        "def get_admin_password():\n",
        "    return \"1234\"\n",
        "\n",
        "# 將保護用的判斷式寫到 secure_function() 內\n",
        "def make_secure(func):\n",
        "    def secure_function():\n",
        "      if user['access_level'] == 'admin':\n",
        "          return func() \n",
        "      else:\n",
        "          return f\"No permission for {user['access_level']} users\"\n",
        "    return secure_function\n",
        "\n",
        "# 獲取「被 decorated 的函數」\n",
        "get_admin_password_basic = make_secure(get_admin_password)\n",
        "# 呼叫剛獲取的 「被decorated 的函數」 \n",
        "get_admin_password_basic()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 699,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "tiAGRbgElj_2",
        "outputId": "f432f2f2-f2dc-4ea4-f61a-ca050802961e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'1234'"
            ]
          },
          "execution_count": 699,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# 好冗，可使用@語法糖(syntax sugar)略過函數傳參過程 \n",
        "# decorator: medium level \n",
        "\n",
        "# user = {'access_level': 'guest'}\n",
        "@make_secure\n",
        "def get_admin_password_medium():\n",
        "    return \"1234\"\n",
        "\n",
        "get_admin_password_medium()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 723,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "id": "BsuL0fqDl_Ik",
        "outputId": "f135b05f-33a5-493f-ea74-7b6d4dc71814"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1234\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "'No admin permissions for guest-level user.'"
            ]
          },
          "execution_count": 723,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# decorator: adavanced level \n",
        "def make_secure(AccessLevel):\n",
        "    def decorator(func):\n",
        "        def wrapper(**kwargs):\n",
        "            access_level = kwargs['access_level']\n",
        "            if access_level == AccessLevel:\n",
        "                return func(**kwargs) \n",
        "            else:\n",
        "                return f\"No {AccessLevel} permissions for {access_level}-level user.\"\n",
        "        return wrapper\n",
        "    return decorator\n",
        "\n",
        "@make_secure('admin')\n",
        "def get_admin_password_advanced(access_level):\n",
        "    return \"1234\"\n",
        "\n",
        "print(get_admin_password_advanced(access_level='admin'))\n",
        "get_admin_password_advanced(access_level='guest')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qgG3_Vr6BzKV"
      },
      "source": [
        "#### Decoraters change function names."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 746,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "id": "XNUvZO2vdz0i",
        "outputId": "f5414462-271d-4b4a-8c40-a987d2a5a7b4"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The wrapped function name is 'hello'\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "'hello meow'"
            ]
          },
          "execution_count": 746,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "def print_func_name(func):\n",
        "    \"\"\"印出被包裝的函數名\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    func : Callable\n",
        "        被包裝的函數\n",
        "    \"\"\"\n",
        "    # @functools.wraps(func)\n",
        "    def wrapper(*args, **kwargs):\n",
        "        print(f\"The wrapped function name is '{func.__name__}'\")\n",
        "        result = func(*args, **kwargs)\n",
        "        return result\n",
        "    return wrapper\n",
        "\n",
        "@print_func_name\n",
        "def hello() -> str:\n",
        "    return 'hello meow'\n",
        "\n",
        "hello()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "30fa7o8wB49W"
      },
      "source": [
        "#### Timer: a decorater that comes in handy."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 784,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NTd7DIrSdz0i",
        "outputId": "55419d61-0583-47b2-f618-04c2facdb42c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "two_sum_brute_force cost:  1.935 (sec)\n",
            "two_sum_hash_table cost:  0.001 (sec)\n"
          ]
        }
      ],
      "source": [
        "from typing import List\n",
        "import random\n",
        "import time\n",
        "\n",
        "def timer(func):\n",
        "    \"\"\"timer decorator(裝飾器)\n",
        "\n",
        "    顯示執行函數 `func` 所需時間\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    func : Callable\n",
        "        想要被包裝的函數\n",
        "    \"\"\"\n",
        "    def wrapper(*args, **kwargs):\n",
        "        start_time = time.time()\n",
        "        result = func(*args, **kwargs)\n",
        "        print(f\"{func.__name__} cost: {time.time() - start_time: .3f} (sec)\")\n",
        "        return result\n",
        "    return wrapper\n",
        "\n",
        "@timer\n",
        "def two_sum_brute_force(array: List[int], target: int) -> List[int]:\n",
        "    \"\"\"2 sum 問題(暴力解 O(n^2))\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    array : List[int]\n",
        "        輸入數組\n",
        "    target : int\n",
        "        目標數字\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    List[Tuple[int]]\n",
        "        數組中兩數字和為目標數字的位置數對(tuple)\n",
        "    \"\"\"\n",
        "    ans = []\n",
        "    for i, u in enumerate(array):\n",
        "        for j, v in enumerate(array[i+1:]):\n",
        "            if u+v == target:\n",
        "                ans.append((i, i+j+1))\n",
        "    return ans\n",
        "\n",
        "@timer\n",
        "def two_sum_hash_table(array: List[int], target: int) -> List[int]:\n",
        "    \"\"\"2 sum 問題(hash table O(n))\"\"\"\n",
        "    ans = []\n",
        "    hash_table = {}\n",
        "\n",
        "    for i, v in enumerate(array):\n",
        "        if v in hash_table:\n",
        "            ans.append((hash_table[v], i))\n",
        "        else:\n",
        "            hash_table[target - v] = i\n",
        "    return ans\n",
        "\n",
        "# 產生測資\n",
        "array = [random.randint(1, 100) for _ in range(10000)]  # 隨機抽出10000個「1到100」中的整數\n",
        "target = random.randint(2, 200)   # 隨機抽出1個「2到200」中的整數\n",
        "\n",
        "_ = two_sum_brute_force(array, target)\n",
        "_ = two_sum_hash_table(array, target)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1Aj66FpVdz0i"
      },
      "source": [
        "## 類別（Class）\n",
        "\n",
        "**類別（Class）** 用來定義自己需要的**物件（Object）** 結構。\n",
        "\n",
        "### 定義類別（Class Definition）\n",
        "\n",
        "定義類別使用 `class` ，裡頭可定義類別的\n",
        "\n",
        "- **類別屬性（Class Attribute）**\n",
        "    - 與類別相關的數值或結構型態變數\n",
        "    - 不需要產生實體也能使用\n",
        "- **實體屬性（Instance Attribute）**\n",
        "    - 透過類別創造出的物件的數值或結構型態變數\n",
        "    - 需要產生實體才能使用\n",
        "    - 需要透過實體才能夠使用\n",
        "    - 每個實體之間屬性可能不同\n",
        "- **實體方法 （Instance Method）**\n",
        "    - 透過類別定義的函數\n",
        "    - 需要產生實體才能使用\n",
        "    - 需要透過實體才能夠使用\n",
        "    - 每個實體之間呼叫結果可能不同\n",
        "- **其他方法（Other Methods）**\n",
        "    - **class method**，使用 `@classmethod` 的裝飾器，定義時第一個參數是 cls（class 本身），與此同時他們將會擁有修改 class state 的權限。他們不需要透過實體化 class 成某個 object 後才能被使用。用 class methods 修改類別屬性時，所有被創建的實體將會被一併套用同樣的修改。\n",
        "    - **static method**，使用 `@staticmethod` 的裝飾器，定義時不需要首個 implicit 引數（self, cls 都不需要），因此他們不能修改 class state。和 class method 類似的是他同樣是綁定在 class 上，不需要實體化某個 object 後就可以直接使用。通常會在 class 中出現的 static methods 作用是 class 內的 helper functions。\n",
        "\n",
        "```python\n",
        "class ClassName:                                  # 類別名稱\n",
        "    class_attribute_1 = some_expression_1             # 類別屬性\n",
        "    class_attribute_2 = some_expression_2             # 類別屬性\n",
        "    \n",
        "    def __init__(self, parameters):                   # 類別建構函數 (constructor)\n",
        "        self.instance_attribute_1 = some_expression_3 # 實體屬性\n",
        "        self.instance_attribute_2 = some_expression_4 # 實體屬性\n",
        "    \n",
        "    def method1(self, parameters):                    # 實體方法\n",
        "        ClassName.class_attribute_1                   # 透過類別呼叫類別屬性\n",
        "        ClassName.class_attribute_2                   # 透過類別呼叫類別屬性\n",
        "        self.instance_attribute_1                     # 透過實體呼叫實體屬性\n",
        "        self.instance_attribute_2                     # 透過實體呼叫實體屬性\n",
        "        \n",
        "    def method2(self, parameters):                    # 實體方法\n",
        "        self.method1(parameters)                      # 透過實體呼叫實體方法\n",
        "```\n",
        "\n",
        "### 宣告物件（Class Declaration）\n",
        "\n",
        "宣告一個為類別的物件，並取用類別的屬性（Attribute）與方法（Method）\n",
        "\n",
        "```python\n",
        "class_instance = ClassName(parameters_list) # 透過類別創造實體\n",
        "class_instance.instance_attribute_1         # 透過實體使用實體屬性\n",
        "class_instance.instance_attribute_2         # 透過實體使用實體屬性\n",
        "class_instance.method1()                    # 透過實體使用實體方法\n",
        "class_instance.method2()                    # 透過實體使用實體方法\n",
        "\n",
        "ClassName.class_attribute_1                 # 透過類別使用類別屬性\n",
        "ClassName.class_attribute_2                 # 透過類別使用類別屬性\n",
        "```\n",
        "\n",
        "### 實體傳遞（Instance Reference）\n",
        "\n",
        "在 python 類別定義中 `self` 為**預設的參數**，代表建立的**物件實體**。\n",
        "\n",
        "- 類似 C-like 語言中的 this pointer\n",
        "- 必定為參數中的第一個\n",
        "- 不一定要取名為 `self`，可以使用任意名字\n",
        "\n",
        "### 繼承（Inheritance）\n",
        "\n",
        "可定義一個繼承親屬類別（Parent Class）的子類別（Child Class）：\n",
        "\n",
        "```python\n",
        "class ParentClass:                         # 定義 ParentClass 類別\n",
        "    parent_class_attribute = some_expression_1\n",
        "    \n",
        "    def __init__(self, parameters):\n",
        "        self.parent_instance_attribute = some_expression_2\n",
        "    \n",
        "    def parent_method(self, parameters):\n",
        "        some_statement\n",
        "        \n",
        "\n",
        "class ChildClass(ParentClass):             # 定義類別 ChildClass 繼承於 ParentClass\n",
        "    def __init__(self, parameters):\n",
        "        super().__init__(parameters)       # 執行 ParentClass.__init__\n",
        "        \n",
        "        ChildClass.parent_class_attribute  # 透過子類別取得親屬類別屬性\n",
        "        self.parent_instance_attribute     # 透過子類別實體取得親屬類別實體屬性\n",
        "        self.parent_method()               # 透過子類別實體呼叫親屬類別實體方法，注意該 parent_method 不可是以 \"__\" 開頭命名的 protected method，否則不會被子類繼承。\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 785,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lDzo7meQdz0i",
        "outputId": "7592a566-97d0-43e8-f73f-cb84a8d0c1ea"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Felix\n",
            "Kjellberg\n",
            "1.81\n",
            "93\n",
            "Felix Kjellberg\n",
            "28.387411861664784\n",
            "Felix Kjellberg, BMI: 28.387411861664784\n",
            "Marzia Bisognin, BMI: 23.140495867768596\n",
            "-------------\n",
            "homo sapiens\n",
            "homo sapiens\n",
            "aaaaaaaaaa\n",
            "aaaaaaaaaa\n"
          ]
        }
      ],
      "source": [
        "# 定義類別\n",
        "\n",
        "# 定義名稱為 Person 的類別\n",
        "class Person:                        \n",
        "    # 建構函數 (constructor)，定義此類別的屬性\n",
        "    # self 代表建立的物件實體，取用實體的屬性及方法皆須加上 self\n",
        "    # first_name 名稱\n",
        "    # last_name 姓氏\n",
        "    # height 身高\n",
        "    # weight 體重   \n",
        "    scientific_name = 'homo sapiens'                         \n",
        "    def __init__(\n",
        "        self,               \n",
        "        first_name,         \n",
        "        last_name,          \n",
        "        height,             \n",
        "        weight):  \n",
        "\n",
        "        self.first_name = first_name  # 定義實體的名稱 = 傳入參數的名稱\n",
        "        self.last_name = last_name    # 定義實體的姓氏 = 傳入參數的姓氏\n",
        "        self.height = height          # 定義實體的身高 = 傳入參數的身高\n",
        "        self.weight = weight          # 定義實體的體重 = 傳入參數的體重\n",
        "    \n",
        "    # 定義實體方法 get_name，回傳姓名\n",
        "    def get_name(self):              \n",
        "        return self.first_name + ' ' + self.last_name\n",
        "    \n",
        "    # 定義實體方法 getBMI，回傳 BMI 數值\n",
        "    def get_BMI(self):               \n",
        "        return self.weight / (self.height ** 2)\n",
        "    \n",
        "    # 定義實體方法 get_info，回傳姓名與 BMI 數值\n",
        "    def get_info(self):              \n",
        "        return self.get_name() + ', BMI: ' + str(self.get_BMI())\n",
        "    @classmethod \n",
        "    def change_scientific_name(cls, new_name):\n",
        "        cls.scientific_name = new_name \n",
        "    \n",
        "   \n",
        "    \n",
        "# 創造類別實體\n",
        "# 宣告 person1 為類別 Person 的實體\n",
        "person1 = Person(\n",
        "    first_name='Felix',            \n",
        "    last_name='Kjellberg',\n",
        "    height=1.81,\n",
        "    weight=93,\n",
        ")\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "# 取得 person1 屬性 first_name 並輸出\n",
        "print(person1.first_name)            \n",
        "# 取得 person1 屬性 last_name 並輸出\n",
        "print(person1.last_name)             \n",
        "# 取得 person1 屬性 height 並輸出\n",
        "print(person1.height)                \n",
        "# 取得 person1 屬性 weight 並輸出\n",
        "print(person1.weight)                \n",
        "# 呼叫 person1 方法 get_name 並輸出\n",
        "print(person1.get_name())            \n",
        "# 呼叫 person1 方法 get_BMI 並輸出\n",
        "print(person1.get_BMI())             \n",
        "# 呼叫 person1 方法 get_info 並輸出\n",
        "print(person1.get_info())            \n",
        "\n",
        "\n",
        "# 宣告 person2 為類別 Person 的實體\n",
        "person2 = Person(\n",
        "    'Marzia',           \n",
        "    'Bisognin',\n",
        "    1.65,\n",
        "    63\n",
        ")\n",
        "\n",
        "# 呼叫 person2 方法 get_info 並輸出\n",
        "print(person2.get_info())   \n",
        "\n",
        "print('-------------')\n",
        "# 呼叫 class attribute \n",
        "print(person1.scientific_name) \n",
        "print(person2.scientific_name) \n",
        "# 改變 class attribute \n",
        "Person.change_scientific_name('aaaaaaaaaa')\n",
        "print(person1.scientific_name) \n",
        "print(person2.scientific_name) "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 786,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O75iEQg6dz0i",
        "outputId": "9b0a7c9c-1e45-49b9-86dc-c3aa2386d2ef"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "---start car Car test---\n",
            "initial speed: 0 m/s\n",
            "speed up 1 time(s), current speed: 10 m/s\n",
            "speed up 2 time(s), current speed: 20 m/s\n",
            "speed up 3 time(s), current speed: 30 m/s\n",
            "slow up 1 time(s),current speed: 20 m/s\n",
            "slow up 2 time(s),current speed: 10 m/s\n",
            "---end car Car test---\n",
            "\n",
            "---start car Lamborghini test---\n",
            "initial speed: 0 m/s\n",
            "speed up 1 time(s), current speed: 5 m/s\n",
            "speed up 2 time(s), current speed: 10 m/s\n",
            "speed up 3 time(s), current speed: 15 m/s\n",
            "slow up 1 time(s),current speed: 10 m/s\n",
            "slow up 2 time(s),current speed: 5 m/s\n",
            "---end car Lamborghini test---\n",
            "\n",
            "---start car Yulon test---\n",
            "initial speed: 0 m/s\n",
            "speed up 1 time(s), current speed: 10 m/s\n",
            "speed up 2 time(s), current speed: 20 m/s\n",
            "speed up 3 time(s), current speed: 30 m/s\n",
            "slow up 1 time(s),current speed: 20 m/s\n",
            "slow up 2 time(s),current speed: 10 m/s\n",
            "---end car Yulon test---\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# 繼承\n",
        "\n",
        "# 定義類別 Car\n",
        "class Car:                                         \n",
        "    # 定義此類別的實體屬性\n",
        "    def __init__(self, max_velocity):              \n",
        "        # 最高速度\n",
        "        self.max_velocity = max(max_velocity, 100) \n",
        "        # 加速度\n",
        "        self.acceleration = 10                     \n",
        "        # 當前速度\n",
        "        self.velocity = 0                          \n",
        "    \n",
        "    # 加速    \n",
        "    def speed_up(self):                            \n",
        "        self.velocity += self.acceleration\n",
        "        # 當前速度無法超過最高速度\n",
        "        if self.velocity > self.max_velocity:      \n",
        "            self.velocity = self.max_velocity\n",
        "    \n",
        "    # 減速\n",
        "    def slow_down(self):                           \n",
        "        self.velocity -= self.acceleration\n",
        "        # 當前速度無法低於 0\n",
        "        if self.velocity < 0:                      \n",
        "            self.velocity = 0\n",
        "    \n",
        "\n",
        "# 定義類別 Lamborghini\n",
        "class Lamborghini(Car):                            \n",
        "    # 定義此類別的實體屬性\n",
        "    def __init__(self, max_velocity):              \n",
        "        # 繼承所有親屬類別的實體屬性\n",
        "        super().__init__(max_velocity)             \n",
        "        # 改寫最高速度\n",
        "        self.max_velocity = max(max_velocity, 300) \n",
        "        # 改寫加速度\n",
        "        self.acceleration = 5                     \n",
        "\n",
        "# 定義類別 Yulon\n",
        "class Yulon(Car):                                  \n",
        "    # 定義此類別的實體屬性\n",
        "    def __init__(self, max_velocity):              \n",
        "        # 繼承所有親屬類別的實體屬性\n",
        "        super().__init__(max_velocity)             \n",
        "        # 改寫最高速度\n",
        "        self.max_velocity = max(max_velocity, 50)  \n",
        "        # 改寫加速度\n",
        "        self.acceleration = 10                      \n",
        "\n",
        "# 測試函數，協助測試各個類別的實體\n",
        "def car_test(car):                                 \n",
        "    # 輸出當前測試實體所屬類別名稱\n",
        "    print(f'---start car {car.__class__.__name__} test---')\n",
        "    # 輸出初始速度\n",
        "    print(f'initial speed: {car.velocity} m/s')\n",
        "    # 加速 3 次\n",
        "    for speed_up_times in range(1, 4):             \n",
        "        car.speed_up()\n",
        "        print(f'speed up {speed_up_times} time(s), '\n",
        "              f'current speed: {car.velocity} m/s')\n",
        "    # 減速 2 次\n",
        "    for slow_down_times in range(1, 3):\n",
        "        car.slow_down()                            \n",
        "        print(f'slow up {slow_down_times} time(s),'\n",
        "              f'current speed: {car.velocity} m/s')\n",
        "    # 輸出結束測試訊息\n",
        "    print(f'---end car {car.__class__.__name__} test---', end='\\n'*2)\n",
        "car1 = Car(100)\n",
        "car2 = Lamborghini(300)\n",
        "car3 = Yulon(50)\n",
        "\n",
        "car_test(car1)\n",
        "car_test(car2)\n",
        "car_test(car3)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lF9CTdPUdz0j"
      },
      "source": [
        "## 模組 (Module)\n",
        "\n",
        "- python 提供內建模組，例如 `math`, `re`, `os` 等\n",
        "- python 也提供安裝模組的功能，主要是透過 `pip` 或是 `conda` 等工具進行安裝\n",
        "\n",
        "### 匯入模組（Module Import）\n",
        "\n",
        "使用 `import` 匯入模組。\n",
        "\n",
        "```python\n",
        "import module_name           # 匯入模組\n",
        "\n",
        "module_name.module_attribute # 透過模組使用模組屬性\n",
        "module_name.module_method()  # 透過模組使用模組方法\n",
        "```\n",
        "\n",
        "使用 `from ... import` **直接匯入**模組屬性或方法。\n",
        "\n",
        "```python\n",
        "from module_name import module_attribute # 直接匯入模組屬性\n",
        "\n",
        "module_attribute                         # 直接使用模組屬性\n",
        "\n",
        "from module_name import module_method    # 直接匯入模組方法\n",
        "\n",
        "module_method()                          # 直接使用模組方法\n",
        "```\n",
        "\n",
        "- `import` 如同 C-like 語言中的 `include`，提供獨立的變數名稱空間（Namespace）\n",
        "- `from ... import` 將模組屬性或方法之接引入當前變數空間\n",
        "    - 讓全域變數（Global Variable）變得更多\n",
        "    - 雖然方便，但是容易產生變數名稱衝突，**不建議使用**\n",
        "\n",
        "### 子模組（Submodule）\n",
        "\n",
        "若模組包含多個子模組，則使用 `.` 進行匯入。\n",
        "\n",
        "```python\n",
        "import parent_module                        # 匯入模組\n",
        "import parent_module.child_module           # 匯入子模組\n",
        "\n",
        "parent_module.child_module.module_attribute # 透過子模組使用模組屬性\n",
        "parent_module.child_module.module_method()  # 透過子模組使用模組方法\n",
        "```\n",
        "\n",
        "### 更改名稱（Rename）\n",
        "\n",
        "python 提供更改模組名稱的語法 `as`。\n",
        "\n",
        "```python\n",
        "import module1.submodule.subsubmodule as m # 匯入模組且更改名稱\n",
        "\n",
        "m.module_attribute                         # 透過更改名稱的模組使用模組屬性\n",
        "m.module_method()                          # 透過更改名稱的模組使用模組方法\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 787,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a2FlXYLqdz0j",
        "outputId": "d4c28d0f-1cca-4c95-8a83-dc7537ea2e7e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3.141592653589793\n",
            "2.0\n",
            "2.302585092994046\n"
          ]
        }
      ],
      "source": [
        "# 匯入模組\n",
        "\n",
        "# 匯入模組 math\n",
        "import math         \n",
        "\n",
        "# 使用 math 模組屬性圓周率\n",
        "print(math.pi)      \n",
        "# 呼叫 math 模組方法，計算 4 的平方根\n",
        "print(math.sqrt(4)) \n",
        "# 呼叫 math 模組方法，計算以自然對數為底的真數為 10 的對數值\n",
        "print(math.log(10)) "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 788,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TM64tPoYdz0j",
        "outputId": "6d9cc017-ad4a-472a-cae6-39ab45cb90d0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3.141592653589793\n",
            "2.0\n",
            "2.302585092994046\n"
          ]
        }
      ],
      "source": [
        "# 匯入模組 math 屬性圓周率\n",
        "from math import pi   \n",
        "# 匯入模組 math 方法平方根\n",
        "from math import sqrt \n",
        "# 匯入模組 math 方法對數\n",
        "from math import log  \n",
        "\n",
        "# 輸出圓周率\n",
        "print(pi)             \n",
        "# 計算 4 的平方根\n",
        "print(sqrt(4))        \n",
        "# 計算以自然對數為底的真數為 10 的對數值\n",
        "print(log(10))        "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kpU6Jg1ydz0j",
        "outputId": "e4693e7a-6735-4dfc-99e1-806db87a186f"
      },
      "outputs": [],
      "source": [
        "# 匯入子模組\n",
        "\n",
        "# 匯入模組 os 中的子模組 path\n",
        "import os.path               \n",
        "\n",
        "# 呼叫 os.path 子模組方法，輸出當前資料夾絕對路徑\n",
        "print(os.path.abspath('./')) "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9vlRnSYudz0j",
        "outputId": "c3c4f7de-0e44-46d9-a27c-b6a828f42192"
      },
      "outputs": [],
      "source": [
        "# 更改名稱\n",
        "\n",
        "# 匯入模組 os 中的子模組 path，並改名為 path\n",
        "import os.path as path       \n",
        "\n",
        "# 呼叫 path 模組方法，輸出當前資料夾絕對路徑\n",
        "print(path.abspath('./'))    "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g0b_2Q4ddz0j"
      },
      "source": [
        "## 錯誤處理（Error Handling）\n",
        "\n",
        "### 基本語法\n",
        "\n",
        "與 C-like 語言相同，python 提供 `try ... except` 進行錯誤處理。\n",
        "\n",
        "- 與 `if`, `for` 語句相同皆須**縮排**\n",
        "- 使用 `raise` 主動製造錯誤\n",
        "\n",
        "```python\n",
        "try:                 # 錯誤包容區塊\n",
        "    some_statements\n",
        "except Error as err: # 錯誤處理區塊\n",
        "    error_handle_statement\n",
        "```\n",
        "\n",
        "> 同一個錯誤處理區塊可以處理**多種不同的錯誤**。\n",
        "\n",
        "```python\n",
        "try:                  # 錯誤包容區塊\n",
        "    some_statements\n",
        "except Error1 as err: # 錯誤處理區塊 1\n",
        "    error_handle_statement\n",
        "except Error2 as err: # 錯誤處理區塊 2\n",
        "    error_handle_statement\n",
        "```\n",
        "\n",
        "> 當錯誤沒有發生時執行else部分\n",
        "\n",
        "```python\n",
        "try:                 # 錯誤包容區塊\n",
        "    some_statements\n",
        "except Error as err: # 錯誤處理區塊\n",
        "    error_handle_statement\n",
        "else:                # 錯誤未發生處理區塊\n",
        "    some_statements\n",
        "```\n",
        "\n",
        "> 如果不論錯誤是否發生**皆需要執行**某些指令，可以使用 `finally` 的區塊執行指令：\n",
        "\n",
        "```python\n",
        "try:                 # 錯誤包容區塊\n",
        "    some_statement\n",
        "except Error as err: # 錯誤處理區塊\n",
        "    error_handle_statement\n",
        "finally:             # 必定執行區塊\n",
        "    some_must_do_statement\n",
        "```\n",
        "\n",
        "> 如果不論錯誤是否發生**皆需要執行**某些指令，可以使用 `finally` 的區塊執行指令：\n",
        "\n",
        "```python\n",
        "try:                 # 錯誤包容區塊\n",
        "    some_statement\n",
        "except Error as err: # 錯誤處理區塊\n",
        "    error_handle_statement\n",
        "else:                # 錯誤未發生處理區塊\n",
        "    some_statement\n",
        "finally:             # 必定執行區塊\n",
        "    some_must_do_statement\n",
        "```\n",
        "\n",
        "### 內建錯誤\n",
        "\n",
        "以下列舉部份內建錯誤型態：\n",
        "\n",
        "\n",
        "|錯誤型態|意義|\n",
        "|-|-|\n",
        "|`IndexError`|當 `list` 存取不存在的位置|\n",
        "|`KeyError`|當 `dict` 存取不存在的鍵值|\n",
        "|`TypeError`|當函數使用參數的型態不正確時|\n",
        "|`ValueError`|當函數使用參數的型態正確但數值範圍不正確時|"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 806,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SkZ-hotvdz0j",
        "outputId": "1d27869a-6941-4673-e27b-f74527bd58dd"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "before error\n",
            "True\n",
            "oops\n"
          ]
        }
      ],
      "source": [
        "# 基本語法\n",
        "\n",
        "try:\n",
        "    # 正常執行\n",
        "    print('before error')          \n",
        "    \n",
        "    # 主動丟出錯誤\n",
        "    raise ValueError('oops')       \n",
        "    \n",
        "    # 因為已經發生錯誤，所以不會執行\n",
        "    print('after error')           \n",
        "\n",
        "# 錯誤處理\n",
        "except ValueError as err:          \n",
        "    # 錯誤種類為 ValueError，所以輸出 True\n",
        "    print(type(err) == ValueError) \n",
        "    # 輸出錯誤訊息\n",
        "    print(err)                     "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 807,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7AwZmfyjdz0j",
        "outputId": "966a5cf1-ea4f-44a0-d761-85fabf223260"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "before error\n",
            "TypeError\n"
          ]
        }
      ],
      "source": [
        "try:\n",
        "    # 正常執行\n",
        "    print('before error')   \n",
        "    # 主動丟出錯誤\n",
        "    raise TypeError('oops') \n",
        "    # 因為已經發生錯誤，所以不會執行\n",
        "    print('after error')    \n",
        "\n",
        "# 因為錯誤種類不是 ValueError，所以不會執行\n",
        "except ValueError as err:   \n",
        "    print('ValueError')\n",
        "\n",
        "# 因為錯誤種類是 TypeError，所以執行錯誤處理\n",
        "except TypeError as err:    \n",
        "    print('TypeError')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 808,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9DaejDQbdz0j",
        "outputId": "fe971292-8131-40ce-b2cf-2eeabca93ff7"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "no error\n",
            "must execute\n",
            "before error\n",
            "oops\n",
            "must execute\n"
          ]
        }
      ],
      "source": [
        "# 沒有錯誤發生\n",
        "try:                         \n",
        "    # 正常執行\n",
        "    print('no error')        \n",
        "# 沒有錯誤發生所以不會執行\n",
        "except ValueError as err:    \n",
        "    print('ValueError')\n",
        "# 沒有錯誤發生仍然會執行\n",
        "finally:                     \n",
        "    print('must execute')\n",
        "\n",
        "\n",
        "# 有錯誤發生\n",
        "try:                         \n",
        "    # 正常執行\n",
        "    print('before error')    \n",
        "    \n",
        "    # 主動丟出錯誤\n",
        "    raise ValueError('oops') \n",
        "    \n",
        "    # 因為已經發生錯誤，所以不會執行\n",
        "    print('after error')     \n",
        "# 錯誤處理\n",
        "except ValueError as err:    \n",
        "    print(err)\n",
        "# 有錯誤發生仍然會執行\n",
        "finally:                     \n",
        "    print('must execute')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 809,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "222-snnsdz0j",
        "outputId": "f054b1b8-1836-4d5f-88e6-22b933135932"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "list index out of range\n",
            "'b'\n",
            "must be real number, not str\n",
            "math domain error\n"
          ]
        }
      ],
      "source": [
        "# 內建錯誤\n",
        "\n",
        "try:\n",
        "    l9 = [1, 2, 3]\n",
        "    # 存取 list l9 不存在的位置\n",
        "    # 觸發 IndexError\n",
        "    l9[3]                 \n",
        "\n",
        "# 處理 IndexError                          \n",
        "except IndexError as err: \n",
        "    print(err)\n",
        "\n",
        "try:\n",
        "    d9 = {'a': 123}\n",
        "    # 存取 dict d9 不存在的鍵值\n",
        "    # 觸發 KeyError\n",
        "    d9['b']               \n",
        "                          \n",
        "# 處理 KeyError\n",
        "except KeyError as err:   \n",
        "    print(err)\n",
        "    \n",
        "import math\n",
        "\n",
        "try:\n",
        "    # math.log 輸入為數字而不是字串\n",
        "    # 觸發 TypeError\n",
        "    math.log('abc')       \n",
        "                          \n",
        "# 處理 TypeError\n",
        "except TypeError as err:  \n",
        "    print(err)\n",
        "\n",
        "try:\n",
        "    # math.log 輸入不可以為負數\n",
        "    # 觸發 ValueError\n",
        "    math.log(-1)          \n",
        "                          \n",
        "# 處理 ValueError                \n",
        "except ValueError as err: \n",
        "    print(err)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y5l3ugdKdz0j"
      },
      "source": [
        "## 練習 1: Bird and Duck (Class Inheritance)\n",
        "- 寫一個 Bird 作為父類別，定義 attributes: 會飛且有兩隻腳\n",
        "    - 在類別中定義一個能夠印出 \"I believe I can fly.\"的實體方法\n",
        "- 寫一個 Duck 繼承 Bird，並且修改 attributes: 不會飛、有兩隻腳，會游泳\n",
        "    - 在類別中定義一個能夠印出 \"I cannot fly.\"的實體方法"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 810,
      "metadata": {
        "id": "n4IpHYAjdz0j"
      },
      "outputs": [],
      "source": [
        "# 練習1解答\n",
        "\n",
        "# 以下稱 Bird 為 super class/base class/parent class\n",
        "# Duck 繼承自 Bird，稱 subclass/child class \n",
        "class Bird:\n",
        "    def __init__(self):\n",
        "        self.can_fly = True\n",
        "        self.two_feet = True\n",
        "        self.has_feather = True \n",
        "        \n",
        "    def fly(self):\n",
        "        print(\"I believe I can fly.\")\n",
        "    "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 811,
      "metadata": {
        "id": "T8a4k8wIdz0k"
      },
      "outputs": [],
      "source": [
        "# 練習1解答\n",
        "\n",
        "class Duck(Bird):\n",
        "    def __init__(self):\n",
        "        super().__init__()    # 繼承父類別 Bird 的 constructor \n",
        "        self.can_fly = False  # 改寫父類別 Bird 的 attribute `.can_fly`\n",
        "        self.two_feet = True  # 改寫父類別 Bird 的 attribute `.two_feet`（可以不定義，因為其值比起所繼承的父類沒有變）\n",
        "        self.can_swim = True  # 新增父類別 Bird 沒有的 attribute `.can_swim`\n",
        "    \n",
        "    def fly(self):            # Override 父類別 Bird 的 object method `.can_swim()`\n",
        "        \"\"\"\n",
        "        In a class hierarchy, \n",
        "        when a method in a subclass has the same name and type signature as a method in its superclass, \n",
        "        then the method in the subclass is said to **override** the method in the superclass. \n",
        "        When an overridden method is called from within a subclass, \n",
        "        it will always refer to the version of that method defined by the subclass.\n",
        "        \"\"\"\n",
        "        print(\"I cannot fly.\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 812,
      "metadata": {
        "id": "-tFVXN8udz0k"
      },
      "outputs": [],
      "source": [
        "# 創建一個 subclass Duck 的實體\n",
        "duck = Duck()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 813,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cwOdVII0dz0k",
        "outputId": "2d37657c-7a10-4724-8143-b3e55745882c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 813,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# subclass Duck 中有定義 attr \n",
        "duck.can_swim"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 814,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "28nMFTFfEhRk",
        "outputId": "2cbb293c-1b67-4e37-8c2c-ce6415b13a86"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 814,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# subclass Duck 中沒有定義 attr ，但繼承自 super class Bird \n",
        "duck.has_feather"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 815,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xBVO0Ukzdz0k",
        "outputId": "61d3b8eb-254d-4639-f4f4-633ef0569404"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "I cannot fly.\n"
          ]
        }
      ],
      "source": [
        "# 呼叫 subclass Duck 中的 .fly() 函數，注意呼叫函數時要帶 () \n",
        "duck.fly()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 816,
      "metadata": {
        "id": "Io37IFridz0k"
      },
      "outputs": [],
      "source": [
        "# 創建一個 super class Duck 的實體\n",
        "bird = Bird()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 817,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P7x1BNjYdz0k",
        "outputId": "af74b546-7673-4b26-940c-d6f8ca9dc80e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "I believe I can fly.\n"
          ]
        }
      ],
      "source": [
        "bird.fly()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8KDZtxIddz0k"
      },
      "source": [
        "## 練習 2: User with confidential information (Class)\n",
        "\n",
        "模擬新增使用者，並對其密碼保護與驗證。\n",
        "\n",
        "- 定義 User 類別\n",
        "    - Attributes (屬性):\n",
        "        1. first_name: str\n",
        "        2. last_name: str\n",
        "        3. email: str\n",
        "        4. __hashed_password: int\n",
        "    - Methods:\n",
        "        1. 使用 __repr__ 定義類別提示\n",
        "        2. 使用 `@property` 與 `@__hashed_password.setter` 設置 __hashed_password 的 getter 與 setter。使外界（實體化後）不可以更改到密碼。\n",
        "        3. check_password方法 檢查輸入的密碼是否正確"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 818,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 369
        },
        "id": "QHmqITU-dz0k",
        "outputId": "40c70aa4-a1b2-4394-b385-fd6a1535b505"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "<User> Tom Li\n",
            "tom.first_name='Tom'\n",
            "tom.last_name='Li'\n",
            "tom.email='xxx@mail'\n",
            "'User' object has no attribute '__hashed_password'\n",
            "False\n",
            "True\n"
          ]
        }
      ],
      "source": [
        "# 練習2解答\n",
        "\n",
        "class User:\n",
        "    \"\"\"User object\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    first_name : str\n",
        "        名\n",
        "    last_name : str\n",
        "        姓\n",
        "    email : str\n",
        "        電子郵件地址\n",
        "    password : str\n",
        "        密碼\n",
        "    \"\"\"\n",
        "    def __init__(self, first_name: str, last_name: str, email: str, password: str):\n",
        "        self.first_name = first_name\n",
        "        self.last_name = last_name\n",
        "        self.email = email\n",
        "        self.__hashed_password = password\n",
        "\n",
        "    def __repr__(self):\n",
        "        return f\"<User> {self.first_name} {self.last_name}\"\n",
        "\n",
        "    @property\n",
        "    def __hashed_password(self) -> int:\n",
        "        \"\"\"取得hashed後的暗碼\n",
        "\n",
        "        Returns\n",
        "        -------\n",
        "        int\n",
        "            hashed後的暗碼\n",
        "        \"\"\"\n",
        "        return self.__hashed_password\n",
        "\n",
        "    @__hashed_password.setter\n",
        "    def __hashed_password(self, password: str) -> None:\n",
        "        \"\"\"將密碼hash\n",
        "\n",
        "        Parameters\n",
        "        ----------\n",
        "        password : str\n",
        "            需加密的密碼\n",
        "        \"\"\"\n",
        "        self.__encrypted_password = hash(password)\n",
        "    \n",
        "    def check_password(self, password: str) -> bool:\n",
        "        \"\"\"檢查密碼是否正確\n",
        "\n",
        "        Parameters\n",
        "        ----------\n",
        "        password : str\n",
        "            需檢查之密碼\n",
        "\n",
        "        Returns\n",
        "        -------\n",
        "        bool\n",
        "            是否與 hashed 前的密碼相同\n",
        "        \"\"\"\n",
        "        return hash(password) == self.__encrypted_password\n",
        "        \n",
        "tom = User('Tom', 'Li', 'xxx@mail', '123')\n",
        "print(tom)\n",
        "print(f\"{tom.first_name=}\")\n",
        "print(f\"{tom.last_name=}\")\n",
        "print(f\"{tom.email=}\")\n",
        "\n",
        "try:\n",
        "    print(tom.__hashed_password) # protected property\n",
        "except AttributeError as e:\n",
        "    print(e)\n",
        "\n",
        "print(tom.check_password(123))\n",
        "print(tom.check_password('123'))"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3.10.4 64-bit",
      "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.16"
    },
    "vscode": {
      "interpreter": {
        "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}