01-quick-start.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python 金融資料的處理應用\n",
    "\n",
    "> Python 快速入門\n",
    "\n",
    "[郭耀仁](https://hahow.in/@tonykuoyj?tr=tonykuoyj) | yaojenkuo@ntu.edu.tw | April 2024"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 關於 Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 關於 Python 的二三事\n",
    "\n",
    "1. Python 的作者是荷蘭電腦科學家 Guido van Rossum\n",
    "2. Python 的命名源於 Guido van Rossum 非常喜歡電視喜劇 Monty Python's Flying Circus\n",
    "3. Python 的第一版釋出於 1991 年。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 寫作與執行 Python 程式需要三種類型的軟體\n",
    "\n",
    "1. 純文字編輯器：寫作程式的軟體，例如記事本、Visual Studio Code 或 Notepad++。\n",
    "2. 終端機：執行程式的軟體，例如 Windows 的命令提示字元、macOS 的 Terminal。\n",
    "3. Python 直譯器：將 Python 程式翻譯為電腦語言的軟體。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Google Colab\n",
    "\n",
    "使用 Google 帳號登入，在雲端使用的 [Google Colab](https://colab.research.google.com)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 初登場的兩個 Python 程式\n",
    "\n",
    "1. 哈囉世界。\n",
    "2. Python 禪學（The Zen of Python）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 哈囉世界\n",
    "\n",
    "- `print()` 是 Python 的內建函數，可以將小括號中的輸入印出。\n",
    "- `\"Hello world!\"` 是屬於 `str` 類別的字面值（Literal value）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello world!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Python 禪學（The Zen of Python）\n",
    "\n",
    "- `import` 是 Python 的保留字（Keywords），可以載入模組。\n",
    "- `this` 是 Python 的一個標準模組，可以印出 Python 禪學。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex.\n",
      "Complex is better than complicated.\n",
      "Flat is better than nested.\n",
      "Sparse is better than dense.\n",
      "Readability counts.\n",
      "Special cases aren't special enough to break the rules.\n",
      "Although practicality beats purity.\n",
      "Errors should never pass silently.\n",
      "Unless explicitly silenced.\n",
      "In the face of ambiguity, refuse the temptation to guess.\n",
      "There should be one-- and preferably only one --obvious way to do it.\n",
      "Although that way may not be obvious at first unless you're Dutch.\n",
      "Now is better than never.\n",
      "Although never is often better than *right* now.\n",
      "If the implementation is hard to explain, it's a bad idea.\n",
      "If the implementation is easy to explain, it may be a good idea.\n",
      "Namespaces are one honking great idea -- let's do more of those!\n"
     ]
    }
   ],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 常見的筆記本使用習慣\n",
    "\n",
    "- 如果程式儲存格只需要一個輸出，直接參照字面值、物件或函數。\n",
    "- 如果程式儲存格需要多個輸出，全部都使用 `print()` 函數。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello world!'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Single output in a code cell\n",
    "hello_world = \"Hello world!\"\n",
    "hello_world"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world!\n",
      "Hello world!\n",
      "Hello world!\n"
     ]
    }
   ],
   "source": [
    "# Multiple outputs in a code cell\n",
    "print(hello_world)\n",
    "print(hello_world)\n",
    "print(hello_world)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 物件與函數的命名規則\n",
    "\n",
    "- 使用全小寫英文，採用蛇形命名法（Snake case），不同單字之間以底線 `_` 相隔。\n",
    "- 不能使用保留字作命名。\n",
    "- 使用單數名詞為資料類別的物件命名、使用複數名詞為資料結構類別的物件命名、使用動詞為函數或方法命名，盡量讓名稱簡潔且具有意義。\n",
    "- 不要使用內建函數作物件的命名，避免覆蓋內建函數的功能。\n",
    "\n",
    "來源：[PEP 8 -- Style Guide for Python Code](https://www.python.org/dev/peps/pep-0008/#function-and-variable-names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 什麼是保留字\n",
    "\n",
    "- 保留字是具有特殊作用的指令。\n",
    "- 目前有看過的 `import`、`def` 與 `return` 等都是 Python 的保留字。\n",
    "- Python 的保留字一覽：<https://docs.python.org/3/reference/lexical_analysis.html#keywords>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 有時候我們在程式碼之中會看到用來解釋的說明文字\n",
    "\n",
    "- 註解（Comments）是口語化的文字敘述，以 `#` 標記，並不能夠被翻譯成電腦語言。\n",
    "- 註解可以細分為單行註解、行末註解。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello world!'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A hello world example\n",
    "hello_world = \"Hello world!\" # hello_world is an instance of str class\n",
    "hello_world                   # show hello_world object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 資料類別"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 五種基礎資料類別\n",
    "\n",
    "1. `int`(integer)\n",
    "2. `float`\n",
    "3. `str`(string)\n",
    "4. `bool`(boolean)\n",
    "5. `NoneType`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 基礎資料類別的存在就是為了讓電腦能夠\n",
    "\n",
    "- 以 `int` 與 `float` 進行數值計算。\n",
    "- 以 `str` 表達與進行文字操作處理。\n",
    "- 以 `bool` 進行流程控制。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'str'>\n",
      "<class 'bool'>\n",
      "<class 'bool'>\n",
      "<class 'NoneType'>\n"
     ]
    }
   ],
   "source": [
    "an_integer = 5566\n",
    "a_float = 3.1415\n",
    "a_string = \"Hello world!\"\n",
    "a_bool_false = False\n",
    "a_bool_true = True\n",
    "a_none_type = None\n",
    "print(type(an_integer))\n",
    "print(type(a_float))\n",
    "print(type(a_string))\n",
    "print(type(a_bool_false))\n",
    "print(type(a_bool_true))\n",
    "print(type(a_none_type))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 資料結構"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 什麼是資料結構\n",
    "\n",
    "> 資料結構是電腦儲存、組織以及取得資料的機制，可以透過程式語言所提供的類別與自行定義類別實現，一個設計良好的資料結構，會在盡可能使用較少的時間與空間資源下，支援各種程式執行。\n",
    "\n",
    "來源：<https://en.wikipedia.org/wiki/Data_structure>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 為什麼需要資料結構\n",
    "\n",
    "- 在資料科學家日常的工作任務中，資料處理佔有相當高的比例。\n",
    "- 需要有一個機制能夠協助他們輸入、處理最後輸出資料。\n",
    "- 這個「機制」就是**資料結構**。\n",
    "- 適當地選擇資料結構，讓資料科學家能夠有效率地儲存與取得資料。\n",
    "- 就像是將食物放置在冰箱、衣服放置在衣櫥、鞋子放置在鞋櫃。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Python 內建的四個資料結構類別\n",
    "\n",
    "1. `list`\n",
    "2. `tuple`\n",
    "3. `dict`(dictionary)\n",
    "4. `set`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## `list`\n",
    "\n",
    "- `list` 是一種「有序」且能夠「更新」的資料結構。\n",
    "- `list` 可以透過「逗號」`,` 分隔值與「中括號」`[]` 形成。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 命名物件作為 `list` 類別的實例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "primes = [2, 3, 5, 7, 11]\n",
    "type(primes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## `tuple`\n",
    "\n",
    "- `tuple` 是一種「有序」且「不能夠更新」的資料結構。\n",
    "- `tuple` 可以透過「逗號」`,` 分隔值與「小括號」`()` 形成。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 命名物件作為 `tuple` 類別的實例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "primes = (2, 3, 5, 7, 11)\n",
    "type(primes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## `tuple` 與 `list` 最大的不同點，在於 `tuple`「不能夠更新」的特性\n",
    "\n",
    "以更新 `list` 的語法更新 `tuple` 會產生錯誤。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'tuple' object does not support item assignment\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    primes[-1] = 13\n",
    "except TypeError as error_message:\n",
    "    print(error_message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## `dict`\n",
    "\n",
    "- `dict` 是一種使用「鍵值對應」關係的資料結構。\n",
    "- `dict` 可以透過「逗號」`,`、「鍵值對應」`key: value` 與「大括號」`{}` 形成。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "the_shawshank_redemption = {\n",
    "    \"title\": \"The Shawshank Redemption\",\n",
    "    \"year\": 1994,\n",
    "    \"rating\": 9.3,\n",
    "    \"director\": \"Frank Darabont\"\n",
    "}\n",
    "type(the_shawshank_redemption)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## `dict` 採用以「鍵」取「值」的索引機制\n",
    "\n",
    "```python\n",
    "dict[\"key\"]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Shawshank Redemption\n",
      "1994\n",
      "9.3\n",
      "Frank Darabont\n"
     ]
    }
   ],
   "source": [
    "print(the_shawshank_redemption[\"title\"])\n",
    "print(the_shawshank_redemption[\"year\"])\n",
    "print(the_shawshank_redemption[\"rating\"])\n",
    "print(the_shawshank_redemption[\"director\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## `set`\n",
    "\n",
    "- `set` 是一種「無序」、儲存「獨一值」並且能夠進行「集合運算」的資料結構。\n",
    "- `set` 可以透過「逗號」`,` 分隔值與「大括號」`{}` 形成。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'set'>\n",
      "<class 'set'>\n"
     ]
    }
   ],
   "source": [
    "primes = {2, 3, 5, 7, 7}  # 7 is duplicated\n",
    "odds = {1, 3, 5, 7, 9, 9} # 9 is duplicated\n",
    "print(type(primes))\n",
    "print(type(odds))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "{2, 3, 5, 7}\n",
      "5\n",
      "{1, 3, 5, 7, 9}\n"
     ]
    }
   ],
   "source": [
    "print(len(primes))\n",
    "print(primes)\n",
    "print(len(odds))\n",
    "print(odds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 流程控制"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 什麼是流程控制\n",
    "\n",
    "多數程式語言都會從程式碼的第一列開始按照列（Row-wise）的順序往下讀取並且執行，但是在某些情況下，我們會希望依據特定的條件來決定程式的執行與否、重複次數以及錯誤發生時該如何應對，這時就可以透過流程控制的結構機制來滿足這些情況。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 什麼是程式區塊\n",
    "\n",
    "> 程式區塊（Code block）有時也被稱為複合語句，是將程式組合並產生依附關係的結構，由一個或多個敘述所組成。\n",
    "\n",
    "來源：<https://en.wikipedia.org/wiki/Block_(programming)>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Python 使用四個空白作為縮排（Indentation）標註程式區塊\n",
    "\n",
    "- 多數程式語言使用大括號 `{}` 來標註程式碼所依附的特定保留字。\n",
    "- 一段程式碼的依附關係從縮排開始直到第一個未縮排的結束。\n",
    "- 縮排必須隨著依附保留字的數量而增加。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 什麼時候需要用到程式區塊\n",
    "\n",
    "- 流程控制。\n",
    "- 定義函數與類別。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 使用「條件」與「縮排」建立條件敘述\n",
    "\n",
    "- 條件指的是一段能夠被解讀為 `bool` 的敘述。\n",
    "- 縮排是 Python 用來辨識程式碼依附區塊的結構，要特別留意。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 使用 `if` 依據條件決定是否執行程式區塊\n",
    "\n",
    "```python\n",
    "if 條件:\n",
    "    # 依附 if 敘述的程式區塊。\n",
    "    # 當條件為 True 的時候程式區塊才會被執行。\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 使用關係運算符或者邏輯運算符描述條件\n",
    "\n",
    "- 關係運算符：`==`, `!=`, `>`, `<`, `>=`, `<=`, `in`, `not in`\n",
    "- 邏輯運算符：`and`, `or`, `not`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "56 is positive.\n",
      "None\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def return_message_if_positive(x):\n",
    "    if x > 0:\n",
    "        return f\"{x} is positive.\"\n",
    "\n",
    "print(return_message_if_positive(56))\n",
    "print(return_message_if_positive(-56))\n",
    "print(return_message_if_positive(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 使用 `if...else...` 依據條件決定執行兩個程式區塊其中的一個\n",
    "\n",
    "```python\n",
    "if 條件:\n",
    "    # 依附 if 敘述的程式區塊。\n",
    "    # 當條件為 True 的時候會被執行。\n",
    "else:\n",
    "    # 依附 else 敘述的程式區塊。\n",
    "    # 當條件為 False 的時候會被執行。\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "56 is positive.\n",
      "0 is not positive.\n",
      "-56 is not positive.\n"
     ]
    }
   ],
   "source": [
    "def return_message_whether_positive_or_not(x):\n",
    "    if x > 0:\n",
    "        return f\"{x} is positive.\"\n",
    "    else:\n",
    "        return f\"{x} is not positive.\"\n",
    "\n",
    "print(return_message_whether_positive_or_not(56))\n",
    "print(return_message_whether_positive_or_not(0))\n",
    "print(return_message_whether_positive_or_not(-56))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 使用 `if...elif...else...` 依據條件決定執行多個程式區塊其中的一個\n",
    "\n",
    "```python\n",
    "if 條件一:\n",
    "    # 依附 if 敘述的程式區塊。\n",
    "    # 當條件一為 True 的時候會被執行。\n",
    "elif 條件二:\n",
    "    # 依附 elif 敘述的程式區塊。\n",
    "    # 當條件一為 False 、條件二為 True 的時候會被執行。\n",
    "else:\n",
    "    # 依附 else 敘述的程式區塊。\n",
    "    # 當條件一、條件二均為 False 的時候會被執行。\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "56 is positive.\n",
      "-56 is negative.\n",
      "0 is neutral.\n"
     ]
    }
   ],
   "source": [
    "def return_message_whether_positive_negative_or_neutral(x):\n",
    "    if x > 0:\n",
    "        return f\"{x} is positive.\"\n",
    "    elif x < 0:\n",
    "        return f\"{x} is negative.\"\n",
    "    else:\n",
    "        return f\"{x} is neutral.\"\n",
    "\n",
    "print(return_message_whether_positive_negative_or_neutral(56))\n",
    "print(return_message_whether_positive_negative_or_neutral(-56))\n",
    "print(return_message_whether_positive_negative_or_neutral(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 使用 `if...elif...` 把所有的條件都寫清楚\n",
    "\n",
    "不一定非要加入 `else`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "56 is positive.\n",
      "-56 is negative.\n",
      "0 is neutral.\n"
     ]
    }
   ],
   "source": [
    "def return_message_whether_positive_negative_or_neutral(x):\n",
    "    if x > 0:\n",
    "        return f\"{x} is positive.\"\n",
    "    elif x < 0:\n",
    "        return f\"{x} is negative.\"\n",
    "    elif x == 0:\n",
    "        return f\"{x} is neutral.\"\n",
    "\n",
    "print(return_message_whether_positive_negative_or_neutral(56))\n",
    "print(return_message_whether_positive_negative_or_neutral(-56))\n",
    "print(return_message_whether_positive_negative_or_neutral(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 什麼是迴圈\n",
    "\n",
    "> 迴圈是流程控制的其中一種技巧，可以讓寫作一次的程式區塊被重複執行，常見的應用是重複執行直到條件不成立時或走訪可迭代類別中的所有元素。\n",
    "\n",
    "來源：<https://en.wikipedia.org/wiki/Control_flow#Loops>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 迴圈的三個要素\n",
    "\n",
    "1. 起始。\n",
    "2. 終止。\n",
    "3. 如何從起始到終止。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 兩種常見的迴圈\n",
    "\n",
    "1. `while` 迴圈：重複執行程式區塊直到條件為 `False` 的時候。\n",
    "2. `for` 迴圈：走訪可迭代類別中的所有元素。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 使用 `while` 依據條件決定是否重複執行程式區塊\n",
    "\n",
    "```python\n",
    "while 條件:\n",
    "    # 依附 while 敘述的程式區塊。\n",
    "    # 當條件為 True 的時候程式區塊會被重複執行。\n",
    "    # 當條件為 False 的時候停止執行程式區塊。\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 如何寫作一個 `while` 迴圈\n",
    "\n",
    "- 在迴圈程式區塊之前定義一個物件設定起始值。\n",
    "- 設計條件讓程式區塊重複執行的次數符合我們的需求。\n",
    "- 記得在程式區塊中更新物件的值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world!\n",
      "Hello, world!\n",
      "Hello, world!\n",
      "Hello, world!\n",
      "Hello, world!\n"
     ]
    }
   ],
   "source": [
    "number_of_prints = 0\n",
    "while number_of_prints < 5:\n",
    "    print(\"Hello, world!\")\n",
    "    number_of_prints = number_of_prints + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 在程式區塊中更新物件的值更常會使用複合運算符（Compound operators）\n",
    "\n",
    "- `integer += 1` 等同於 `integer = integer + 1` \n",
    "- `integer -= 1` 等同於 `integer = integer - 1` \n",
    "- `integer *= 1` 等同於 `integer = integer * 1` \n",
    "- `integer /= 1` 等同於 `integer = integer / 1` \n",
    "- ...等。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 使用 `for` 走訪可迭代類別（Iterables）中的所有元素\n",
    "\n",
    "```python\n",
    "for 元素 in 可迭代類別:\n",
    "    # 依附 for 敘述的程式區塊。\n",
    "    # 當可迭代類別還沒有走訪完的時候程式區塊會被重複執行。\n",
    "    # 當可迭代類別走訪完的時候停止執行程式區塊。\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 什麼是可迭代類別\n",
    "\n",
    "具有一次回傳其中一個資料值特性的類別、輸入到內建函數 `iter()` 不會產生錯誤的類別，都屬於可迭代類別（Iterables），常見的有 `str` 與資料結構。\n",
    "\n",
    "- 資料類別：`str`\n",
    "- 資料結構類別：`list`、`tuple`、`dict`、`set`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<list_iterator at 0x11272c040>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "luke = \"Luke Skywalker\"\n",
    "primes = [2, 3, 5, 7, 11]\n",
    "iter(luke)\n",
    "iter(primes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 如何寫作一個 `for` 迴圈\n",
    "\n",
    "- 建立一個可迭代類別。\n",
    "- 可迭代類別如果是數列，可透過內建函數 `range()` 建立。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world!\n",
      "Hello, world!\n",
      "Hello, world!\n",
      "Hello, world!\n",
      "Hello, world!\n"
     ]
    }
   ],
   "source": [
    "for element in range(0, 5, 1):\n",
    "    print(\"Hello, world!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 以兩個保留字調整迴圈的重複執行次數\n",
    "\n",
    "1. `break` 保留字可以提早結束。\n",
    "2. `continue` 保留字可以略過某些執行次數。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 遇到星期四提早結束"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sunday\n",
      "Monday\n",
      "Tuesday\n",
      "Wednesday\n"
     ]
    }
   ],
   "source": [
    "days_of_week = [\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"]\n",
    "for day in days_of_week:\n",
    "    if day == \"Thursday\":\n",
    "        break\n",
    "    print(day)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 略過週末"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Monday\n",
      "Tuesday\n",
      "Wednesday\n",
      "Thursday\n",
      "Friday\n"
     ]
    }
   ],
   "source": [
    "days_of_week = [\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"]\n",
    "for day in days_of_week:\n",
    "    if day in {\"Sunday\", \"Saturday\"}:\n",
    "        continue\n",
    "    print(day)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 組織程式碼的機制"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 什麼是組織程式碼\n",
    "\n",
    "面對不同目的以及應用場景，我們會有組織程式碼的需求，簡單來說，是希望程式碼可以簡潔且有效率地完成任務。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 組織程式碼希望達到的目標最主要有兩個：\n",
    "\n",
    "1. 提高程式碼的「可利用性」。\n",
    "2. 減少程式碼的「重複性」。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Python 提供三種機制供使用者組織程式碼\n",
    "\n",
    "視應用範疇由小到大依序為：\n",
    "\n",
    "1. 函數（Function）。\n",
    "2. 類別（Class）。\n",
    "3. 模組（Module）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 如何理解程式碼組織機制的層次\n",
    "\n",
    "- 數行程式碼可以組織為一個函數。\n",
    "- 數個函數可以組織為一個類別。\n",
    "- 數個函數或類別可以組織為一個模組。\n",
    "- 數個模組可以組織為一個功能更多的模組。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 函數"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 什麼是函數\n",
    "\n",
    "一段被賦予名稱的程式碼，能夠完成某一個文字處理或者數值計算任務，在使用函數之前，必須先確定這個函數在執行的環境中已經被定義妥善。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 函數有四個來源\n",
    "\n",
    "1. 來自內建函數。\n",
    "2. 來自標準模組。\n",
    "3. 來自第三方模組。\n",
    "4. 來自使用者的定義。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 如何自行定義函數\n",
    "\n",
    "- `def` 保留字用來定義函數的名稱。\n",
    "- 縮排部分稱為程式區塊（Code block），是函數的主體，也是練習題要學員運用預期輸入與參數來完成的部分。\n",
    "- 不要忘記把函數的預期輸出寫在 `return` 保留字後。\n",
    "- 函數的類別提示（Typing）並不是必要的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 自行定義函數的結構\n",
    "\n",
    "```python\n",
    "def function_name(INPUTS: TYPE, ARGUMENTS: TYPE) -> TYPE:\n",
    "    ### BEGIN SOLUTION\n",
    "    OUTPUTS = INPUTS (+-*/...) ARGUMENTS\n",
    "    return OUTPUTS\n",
    "    ### END SOLUTION\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 定義與使用函數的差別\n",
    "\n",
    "- 完成定義函數以後，還需要使用函數才會將引數傳入運算。\n",
    "- 定義函數的當下只有與語法錯誤相似的錯誤（例如縮排錯誤）會發起例外。\n",
    "- 如果是執行錯誤，在使用函數時才會發起。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 以資料結構類別處理函數的「多個輸出」\n",
    "\n",
    "- 預設以 `tuple` 資料結構類別應對多個輸出。\n",
    "- 可以自行調整偏好的資料結構類別。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('P', 'n')\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "def get_first_and_last_characters(x):\n",
    "    first_character = x[0]\n",
    "    last_character = x[-1]\n",
    "    return first_character, last_character # did not specify a tuple with ()\n",
    "\n",
    "print(get_first_and_last_characters(\"Python\"))\n",
    "print(type(get_first_and_last_characters(\"Python\")))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 指定用 `list` 輸出"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['P', 'n']\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "def get_first_and_last_characters(x):\n",
    "    first_character = x[0]\n",
    "    last_character = x[-1]\n",
    "    return [first_character, last_character] # specify a list with []\n",
    "\n",
    "print(get_first_and_last_characters(\"Python\"))\n",
    "print(type(get_first_and_last_characters(\"Python\")))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 指定用 `dict` 輸出"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'first': 'P', 'last': 'n'}\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "def get_first_and_last_characters(x):\n",
    "    first_character = x[0]\n",
    "    last_character = x[-1]\n",
    "    output = {\n",
    "        \"first\": first_character,\n",
    "        \"last\": last_character\n",
    "    }\n",
    "    return output # specify a dict\n",
    "\n",
    "print(get_first_and_last_characters(\"Python\"))\n",
    "print(type(get_first_and_last_characters(\"Python\")))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 以資料結構類別或彈性參數處理函數的「多個輸入」\n",
    "\n",
    "- 運用資料結構類別作為一個輸入物件名稱。\n",
    "- 運用彈性參數。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 運用資料結構類別作為一個輸入物件名稱"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "289\n"
     ]
    }
   ],
   "source": [
    "def sum_and_square(x):\n",
    "    summation = sum(x)\n",
    "    output = summation**2\n",
    "    return output\n",
    "\n",
    "print(sum_and_square([2, 3, 5]))    # [2, 3, 5] as input\n",
    "print(sum_and_square((2, 3, 5, 7))) # (2, 3, 5, 7) as input"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 利用 `*` 標註彈性參數\n",
    "\n",
    "- `args` 可以在函數程式區塊中作為一個 `tuple` 供運用。\n",
    "- `args` 可以任意使用偏愛的命名。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "100\n",
      "<class 'tuple'>\n",
      "289\n"
     ]
    }
   ],
   "source": [
    "def sum_and_square(*args):\n",
    "    print(type(args))\n",
    "    summation = sum(args)\n",
    "    output = pow(summation, 2)\n",
    "    return output\n",
    "\n",
    "print(sum_and_square(2, 3, 5))    # 2, 3, 5 as input\n",
    "print(sum_and_square(2, 3, 5, 7)) # 2, 3, 5, 7 as input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "289\n"
     ]
    }
   ],
   "source": [
    "def sum_and_square(*arguments):\n",
    "    summation = sum(arguments)\n",
    "    output = pow(summation, 2)\n",
    "    return output\n",
    "\n",
    "print(sum_and_square(2, 3, 5))\n",
    "print(sum_and_square(2, 3, 5, 7))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 利用 `**` 標註具有「鍵」與「值」的彈性參數\n",
    "\n",
    "- `kwargs` 可以在函數程式區塊中作為一個 `dict` 供運用。\n",
    "- `kwargs` 可以任意使用偏愛的命名。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "Country: JPN Capital: Tokyo\n",
      "Country: USA Capital: Washington D.C.\n",
      "Country: TWN Capital: Taipei\n"
     ]
    }
   ],
   "source": [
    "def print_country_capital(**kwargs):\n",
    "    print(type(kwargs)) # dict\n",
    "    for key, value in kwargs.items():\n",
    "        print(f\"Country: {key} Capital: {value}\")\n",
    "\n",
    "print_country_capital(JPN=\"Tokyo\", USA=\"Washington D.C.\", TWN=\"Taipei\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Country: JPN Capital: Tokyo\n",
      "Country: USA Capital: Washington D.C.\n",
      "Country: TWN Capital: Taipei\n"
     ]
    }
   ],
   "source": [
    "def print_country_capital(**dictionary):\n",
    "    for key, value in dictionary.items():\n",
    "        print(f\"Country: {key} Capital: {value}\")\n",
    "\n",
    "print_country_capital(JPN=\"Tokyo\", USA=\"Washington D.C.\", TWN=\"Taipei\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## `return` 保留字的兩個作用\n",
    "\n",
    "1. 回傳函數的預期輸出。\n",
    "2. 為函數的程式區塊畫下終止符。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 回傳函數的預期輸出\n",
    "\n",
    "- 沒有 `return` 的函數事實上的輸出是 `None`\n",
    "- 這也是練習題如果沒有將預期輸出寫在 `return` 保留字後，無法通過批改測試的原因。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def power(x, n):\n",
    "    \"\"\"\n",
    "    Equivalent to x raised to the power of n.\n",
    "    \"\"\"\n",
    "    output = x**n\n",
    "\n",
    "type(power(5, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 為函數的程式區塊畫下終止符\n",
    "\n",
    "即便寫在縮排的函數程式區塊之中，`return` 後所寫的程式並沒有作用。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "125"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def power(x, n):\n",
    "    \"\"\"\n",
    "    Equivalent to x raised to the power of n.\n",
    "    \"\"\"\n",
    "    out = x**n\n",
    "    return out\n",
    "    print(x)\n",
    "    print(n)\n",
    "\n",
    "power(5, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 類別"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 什麼是類別\n",
    "\n",
    "自行設計資料或者資料結構的機制，能夠將多個函數與資料組織起來使用，定義「類別」也是入門物件導向程式設計的第一步。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 兩種不同的程式設計\n",
    "\n",
    "1. 程序型程式設計（Procedural programming）。\n",
    "2. 物件導向程式設計（Object-oriented programming, OOP）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 程序型程式設計\n",
    "\n",
    "以函數為主體的撰寫程式型態稱為「程序型程式設計（Procedural programming）」，把即將要執行的程式碼組織為函數，並依序使用這些函數來完成任務。\n",
    "\n",
    "```python\n",
    "def function_one():\n",
    "    ...\n",
    "    return ...\n",
    "    \n",
    "def function_two():\n",
    "    ...\n",
    "    return ...\n",
    "\n",
    "function_one()\n",
    "function_two()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 物件導向程式設計\n",
    "\n",
    "除了程序型程式設計，另外一種在軟體開發中被採用的撰寫程式型態稱為「物件導向程式設計（Object-oriented programming, OOP）」。\n",
    "\n",
    "```python\n",
    "class class_one:\n",
    "    def method_one(self):\n",
    "        ...\n",
    "        return ...\n",
    "\n",
    "object_one = class_one()\n",
    "object_one.method_one()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 常用的內建類別\n",
    "\n",
    "- 資料\n",
    "    - `int`\n",
    "    - `float`\n",
    "    - `str`\n",
    "    - `bool`\n",
    "    - `NoneType`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 常用的內建類別（續）\n",
    "\n",
    "- 資料結構\n",
    "    - `list`\n",
    "    - `tuple`\n",
    "    - `dict`\n",
    "    - `set`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 資料科學模組主要提供的類別\n",
    "\n",
    "- 資料結構：\n",
    "    - `ndarray`\n",
    "    - `Index`\n",
    "    - `Series`\n",
    "    - `DataFrame`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 設計類別時可以定義函數與資料\n",
    "\n",
    "- 在類別程式區塊中定義的函數，實例化後稱為物件的方法（Methods）。\n",
    "- 在類別程式區塊中定義的資料，實例化後稱為物件的屬性（Attributes）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 使用 `class` 保留字定義類別\n",
    "\n",
    "> 類別的命名習慣與物件、函數不同，非採用蛇形命名法，而是採用首字大寫的 CapWords 命名法。\n",
    "\n",
    "來源：<https://www.python.org/dev/peps/pep-0008/#class-names>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 在類別程式區塊中使用 `def` 保留字定義函數\n",
    "\n",
    "在類別程式區塊中定義的函數，實例化後稱為物件的**方法**。\n",
    "\n",
    "```python\n",
    "class ClassName:\n",
    "    def method_name(self):\n",
    "        ...\n",
    "        return ...\n",
    "\n",
    "object_name = ClassName()\n",
    "object_name.method_name()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 如何理解 `self`\n",
    "\n",
    "- 使用物件的方法必須要指定物件名稱：`object.method()`\n",
    "- 可是設計類別的人不會知道物件名稱為何，因為實例化的物件名稱是由使用者所決定的。\n",
    "- 若是要在定義類別的階段描述方法，就必須先給物件一個代名詞：`self` 作為第一個參數名稱。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class SimpleCalculator:\n",
    "    def add(self, a, b):\n",
    "        return a + b\n",
    "\n",
    "simple_calculator = SimpleCalculator()\n",
    "simple_calculator.add(5, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 如何理解 `self`（續）\n",
    "\n",
    "- 事實上，也不一定要用 `self` 作為第一個參數的名稱，可以用偏好的命名。\n",
    "- 但是 Python 的使用者都習慣 `self`\n",
    "\n",
    "來源：<https://www.python.org/dev/peps/pep-0008/#function-and-method-arguments>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "121"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class SimpleCalculator:\n",
    "    def add(myself, a, b): # use myself instead of self\n",
    "        return a + b\n",
    "\n",
    "simple_calculator = SimpleCalculator()\n",
    "simple_calculator.add(55, 66)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 在類別程式區塊中定義函數 `__init__()` 定義資料\n",
    "\n",
    "- 在類別程式區塊中定義的資料，實例化後稱為物件的屬性。\n",
    "- `__init__()` 函數顧名思義就是在實例化當下就會起作用的函數。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n",
      "66\n"
     ]
    }
   ],
   "source": [
    "class SimpleCalculator:\n",
    "    \"\"\"\n",
    "    This class creates an instance with 2 custom attributes.\n",
    "    \"\"\"\n",
    "    def __init__(self, a, b):\n",
    "        self.a = a\n",
    "        self.b = b\n",
    "\n",
    "simple_calculator = SimpleCalculator(55, 66)\n",
    "print(simple_calculator.a)\n",
    "print(simple_calculator.b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 如何理解 `self`（續）\n",
    "\n",
    "- 在使用物件的屬性時必須要指定物件名稱：`object.attribute`\n",
    "- 可是設計類別的人不會知道物件名稱為何，因為實例化的物件名稱是由使用者所決定的。\n",
    "- 若是要在定義類別的時候描述屬性，就必須先給物件一個代名詞：`self` 作為第一個參數名稱。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 以 `self.attribute` 在類別程式區塊中使用屬性"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "121"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class SimpleCalculator:\n",
    "    \"\"\"\n",
    "    This class creates an instance with 2 custom attributes and 1 custom method.\n",
    "    \"\"\"\n",
    "    def __init__(self, a, b):\n",
    "        self.a = a\n",
    "        self.b = b\n",
    "    def add(self):\n",
    "        return self.a + self.b # retrieve via self.a, self.b\n",
    "\n",
    "simple_calculator = SimpleCalculator(55, 66) # self proxies object simple_calculator\n",
    "simple_calculator.add()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 以 `self.method()` 在類別程式區塊中使用方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14641\n"
     ]
    }
   ],
   "source": [
    "class SimpleCalculator:\n",
    "    \"\"\"\n",
    "    This class creates an instance with 2 custom attributes and 2 custom methods.\n",
    "    \"\"\"\n",
    "    def __init__(self, a, b):\n",
    "        self.a = a\n",
    "        self.b = b\n",
    "    def add(self):\n",
    "        return self.a + self.b # retrieve via self.a, self.b\n",
    "    def add_then_square(self):\n",
    "        return (self.add())**2 # use via self.add()\n",
    "\n",
    "simple_calculator = SimpleCalculator(55, 66)\n",
    "print(simple_calculator.add_then_square())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 模組"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 什麼是模組\n",
    "\n",
    "模組（Module）指的是以檔案或資料夾形式，來組織 Python 的函數以及類別。檔案形式可以對應「數個函數或類別可以組織為一個模組」層次、資料夾形式可以對應「數個模組可以組織為一個功能更多的模組」層次。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 模組有三個來源\n",
    "\n",
    "1. 標準模組。\n",
    "2. 來自使用者的定義。\n",
    "3. 第三方模組。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 標準模組（Standard libraries）\n",
    "\n",
    "- 伴隨 Python 直譯器（來自 [python.org](https://www.python.org) 的版本）安裝的模組。\n",
    "- 可以直接載入並使用。\n",
    "- 有哪些標準模組可以直接載入並使用：<https://docs.python.org/3/library>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 使用 `import`、`from` 與 `as` 保留字\n",
    "\n",
    "- 使用 `import` 載入模組。\n",
    "- 使用 `from module import function/class` 載入模組中特定的函數或類別。\n",
    "- 使用 `as` 調整模組、函數或者類別的命名。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 使用 `import` 載入模組\n",
    "\n",
    "- 以 `module` 命名使用。\n",
    "- 使用模組中的函數、類別時都以 `module.function()` 或 `module.class()` 來參照命名。\n",
    "\n",
    "```python\n",
    "import module\n",
    "\n",
    "module.function()\n",
    "object = module.class()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/Users/kuoyaojen/classroom-python-for-finance-2024'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2024-01-01\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "\n",
    "first_day_of_2024 = datetime.date(2024, 1, 1)\n",
    "print(first_day_of_2024)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 使用 `from module import function/class` 載入模組中特定的函數或類別\n",
    "\n",
    "載入特定函數或類別，就直接以 `function()` 或 `class()` 來參照命名。\n",
    "\n",
    "```python\n",
    "from module import function\n",
    "from module import class\n",
    "\n",
    "function()\n",
    "object = class()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/Users/kuoyaojen/classroom-python-for-finance-2024'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from os import getcwd\n",
    "\n",
    "getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2024-01-01\n"
     ]
    }
   ],
   "source": [
    "from datetime import date\n",
    "\n",
    "first_day_of_2024 = date(2024, 1, 1)\n",
    "print(first_day_of_2024)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 使用 `as` 調整模組、函數或者類別的命名\n",
    "\n",
    "```python\n",
    "import module as module_alias\n",
    "from module import function as function_alias\n",
    "from module import class as class_alias\n",
    "\n",
    "module_alias.function()\n",
    "function_alias()\n",
    "object = class_alias()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/Users/kuoyaojen/classroom-python-for-finance-2024\n",
      "/Users/kuoyaojen/classroom-python-for-finance-2024\n"
     ]
    }
   ],
   "source": [
    "import os as operating_system\n",
    "from os import getcwd as get_current_working_directory\n",
    "\n",
    "print(operating_system.getcwd())\n",
    "print(get_current_working_directory())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2024-01-01\n",
      "2024-01-01\n"
     ]
    }
   ],
   "source": [
    "import datetime as dttm\n",
    "from datetime import date as dt\n",
    "\n",
    "first_day_of_2024 = dttm.date(2024, 1, 1)\n",
    "print(first_day_of_2024)\n",
    "first_day_of_2024 = dt(2024, 1, 1)\n",
    "print(first_day_of_2024)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 如何決定模組載入的形式\n",
    "\n",
    "- `import module`\n",
    "- `import module as alias`\n",
    "- `from module import function/class`\n",
    "- `from module import function/class as alias`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 如何決定模組載入的形式（續）\n",
    "\n",
    "- 依照模組說明文件（Documentation）中的範例決定。\n",
    "- 例如：使用 `os` 模組時採用 `import os`\n",
    "- 例如：使用 `datetime` 模組時採用 `from datetime import function/class`\n",
    "\n",
    "來源：<https://docs.python.org/3/library/os.html#file-object-creation>, <https://docs.python.org/3/library/datetime.html#examples-of-usage-date>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/Users/kuoyaojen/classroom-python-for-finance-2024'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2024-01-01\n"
     ]
    }
   ],
   "source": [
    "from datetime import date\n",
    "\n",
    "first_day_of_2024 = date(2024, 1, 1)\n",
    "print(first_day_of_2024)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 環境管理"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 關於 Python 程式語言的描述\n",
    "\n",
    "- 直譯式。\n",
    "- 動態類別。\n",
    "- 物件導向。\n",
    "- **泛用**。\n",
    "- ...等。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Python 是廣泛用途的程式語言\n",
    "\n",
    "廣泛用途（General-purposed）是指作者 Guido van Rossum 在開發 Python 的過程中並沒有針對特定的應用場景去設計語言特性，而是交由程式語言的「使用者」利用第三方模組自行發展。而因為 Python 有大量來自不同領域的使用者，也使得其應用場景非常多元而且發展蓬勃。\n",
    "\n",
    "- 資料科學。\n",
    "- 網頁應用程式開發。\n",
    "- 桌面軟體使用者介面開發。\n",
    "- 遊戲開發。\n",
    "- ...等。\n",
    "\n",
    "來源：<https://www.python.org/about/apps/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 什麼是環境管理\n",
    "\n",
    "當程式語言的應用場景多元，伴隨而來的就是要依據專案需求安裝設定不同的 Python 版本以及不同的模組版本。在一台電腦管理軟體版本，確保各個專案的開發環境不會受到彼此影響的機制，就稱為環境管理。\n",
    "\n",
    "- 專案一需要 Python 3.9 與 NumPy/Pandas 模組進行資料科學。\n",
    "- 專案二需要 Python 3.8 與 Flask/Django 模組進行網頁應用程式開發。\n",
    "- 專案三需要 Python 3.7 與 PyQt/Kivy 模組進行桌面軟體使用者介面開發。\n",
    "- ...等。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 環境管理可以理解為管理軟體版本\n",
    "\n",
    "- Python 版本。\n",
    "- 模組版本。\n",
    "\n",
    "掌握環境管理是從 Python 初學者成長為進階者的重要里程碑。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 標準的 Python 版本與模組管理工具\n",
    "\n",
    "- Python 版本管理：標準模組 `venv`：<https://docs.python.org/3/tutorial/venv.html>\n",
    "- 模組版本管理：第三方模組 `pip`：<https://pip.pypa.io/en/stable>，雖然 `pip` 是第三方模組，但因為太受歡迎，自從 Python 3.4 以後已經變得像標準模組一樣會伴隨 Python 直譯器而安裝。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## conda 可以同時管理 Python 版本與模組版本\n",
    "\n",
    "> conda 是一個開源的跨平台、跨程式語言軟體，能夠在 Windows、macOS 與 Linux 上安裝運行，它被設計作為 Python、R、Scala 與 Java 等任何程式語言的模組、依賴性以及工作環境管理軟體。\n",
    "\n",
    "來源：<https://conda.io/projects/conda/en/latest/index.html>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## conda 以終端機作為執行介面\n",
    "\n",
    "- 安裝 [Minoconda](https://docs.anaconda.com/free/miniconda) 的同時就會安裝好 conda。\n",
    "- Miniconda 是 Anaconda 輕量的版本，基本只會在電腦中安裝特定 Python 直譯器版本與 conda\n",
    "- 開啟終端機\n",
    "    - macOS: Terminal\n",
    "    - Windows: Anaconda Prompt\n",
    "- 檢視 conda 的版本來確定已經安裝妥當。\n",
    "\n",
    "```bash\n",
    "conda --version\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 檢視環境清單\n",
    "\n",
    "- 顯示所有可以使用的環境名稱與安裝路徑。\n",
    "- 以 `*` 標註目前所在的環境。\n",
    "\n",
    "```bash\n",
    "conda env list\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 檢視目前所在環境的 Python 版本\n",
    "\n",
    "環境名稱：`base`\n",
    "\n",
    "```bash\n",
    "(base) python --version\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 在 base 環境安裝 jupyterlab\n",
    "\n",
    "環境名稱：`base`\n",
    "\n",
    "```bash\n",
    "(base) conda install jupyterlab\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 建立環境\n",
    "\n",
    "- 環境名稱：`pythonfinance`\n",
    "- Python 版本：3.11\n",
    "\n",
    "```bash\n",
    "(base) conda create --name pythonfinance python=3.11\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 啟動環境\n",
    "\n",
    "- 環境名稱：`pythonfinance`\n",
    "- 啟動之後會終端機會出現環境名稱提示 `(pythonfinance)`\n",
    "\n",
    "```bash\n",
    "(base) conda activate pythonfinance\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 在目前環境安裝資料科學與財務金融模組\n",
    "\n",
    "環境名稱：`pythonfinance`\n",
    "\n",
    "```bash\n",
    "(pythonfinance) pip install ipykernel numpy pandas xlrd openpyxl matplotlib requests websockets aiosqlite dash\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 新增 Jupyter Notebook 的運算核心\n",
    "\n",
    "- 環境名稱：`pythonfinance`\n",
    "- 運算核心顯示名稱：`Python Finance`\n",
    "\n",
    "```bash\n",
    "(pythonfinance) python -m ipykernel install --user --name pythonfinance --display-name \"Python Finance\"\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 新增一個運算核心為 `Python Finance` 的筆記本\n",
    "\n",
    "- 輸入 `conda deactivate` 回到 base 環境。\n",
    "- 輸入 `jupyter lab` 後按下 Enter\n",
    "- 點選 Notebook Python Finance\n",
    "- 透過標準模組 `sys` 在 Jupyter Notebook 中檢視 Python 版本。\n",
    "\n",
    "```python\n",
    "# Run in Jupyter Notebook instead of Terminal\n",
    "import sys\n",
    "\n",
    "print(sys.version)\n",
    "```"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}