ABC_to_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 縮排 (Indentation)\n",
    "Python使用縮排來切分程式碼，這和其他語言使用 {} 不同。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:13.825514Z",
     "start_time": "2019-03-05T02:56:13.794269Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "finish\n"
     ]
    }
   ],
   "source": [
    "for i in [1, 2, 3]:\n",
    "\tprint(i)\n",
    "\tfor j in [1, 2, 3, 4]:\n",
    "\t\tprint(j + i)\n",
    "\n",
    "print('finish')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "看到以下錯誤就該檢查一下縮排了\n",
    "\n",
    "`IndentationError: expected an indented block`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 註解(Comments)\n",
    "所有在#後的文字都會被當成註解"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:13.856761Z",
     "start_time": "2019-03-05T02:56:13.841142Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Python!\n"
     ]
    }
   ],
   "source": [
    "#!/usr/bin/python3\n",
    "\n",
    "# First comment\n",
    "print (\"Hello, Python!\") # second comment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 命名規則(Identifiers)\n",
    "* Identifiers can be a combination of letters in lowercase (a to z) or uppercase (A to Z) or digits (0 to 9) or an underscore (_).\n",
    "* Python is a case sensitive, so MACHINE and machine are different.\n",
    "* 不可使用@, $, and %。\n",
    "[Google 建議的 Python 風格指南 35-37](https://www.ptt.cc/bbs/Translate-CS/M.1372612455.A.463.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 保留字(Reserved Words)\n",
    "不要取和保留字相似的變數，這是自找麻煩。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:13.903632Z",
     "start_time": "2019-03-05T02:56:13.872386Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python version:  sys.version_info(major=3, minor=6, micro=5, releaselevel='final', serial=0)\n",
      "Python keywords:  ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "import keyword\n",
    "\n",
    "print(\"Python version: \", sys.version_info)\n",
    "print(\"Python keywords: \", keyword.kwlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 在一行內放入多個敘述(Multiple Statements on a Single Line)\n",
    "python允許在一行內放入多個敘述，只要在不同敘述間用semicolon ( ; )隔開即可。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:13.919260Z",
     "start_time": "2019-03-05T02:56:13.903632Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Python!\n",
      "Hello, 123!\n"
     ]
    }
   ],
   "source": [
    "print (\"Hello, Python!\"); print (\"Hello, 123!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 匯入(import)\n",
    "Python生態系有豐富的模組，要使用這些模組就使用import，通常都會把需要 import 的 模組列在整個檔案的最一開始，但不是必須。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:13.950504Z",
     "start_time": "2019-03-05T02:56:13.919260Z"
    }
   },
   "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": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:13.966124Z",
     "start_time": "2019-03-05T02:56:13.950504Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n"
     ]
    }
   ],
   "source": [
    "#沒有import math，連開根號都不能用\n",
    "b=sqrt(4.0)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 語法1：import [module]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:13.997372Z",
     "start_time": "2019-03-05T02:56:13.981749Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n"
     ]
    }
   ],
   "source": [
    "# Import 整個 `math` module\n",
    "import math\n",
    "\n",
    "b=sqrt(4.0)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:14.028620Z",
     "start_time": "2019-03-05T02:56:13.997372Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "# 使用 `math` module 底下的 `sqrt` function\n",
    "b=math.sqrt(4.0)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 語法2：from [module] import [name1, name2, ...]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:14.044241Z",
     "start_time": "2019-03-05T02:56:14.028620Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n"
     ]
    }
   ],
   "source": [
    "# 從 `math` module 裡 import 其中一個 function `sqrt`\n",
    "from math import sqrt\n",
    "\n",
    "# 不一樣的是，使用 `sqrt` 的時候就不需要先寫 `math` 了\n",
    "b=sqrt(4.0)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 語法3：import [module] as [new_name]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:14.059864Z",
     "start_time": "2019-03-05T02:56:14.044241Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n"
     ]
    }
   ],
   "source": [
    "# Import 整個 `math` module，\n",
    "# 但這個名字可能跟其他地方有衝突或者名字太長，因此改名成 `mt` \n",
    "import math as mt\n",
    "\n",
    "# 使用 `mt` 這個名稱取代原本的 `math`\n",
    "b=mt.sqrt(4.0)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 語法4（不推薦）：from [module] import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:14.091110Z",
     "start_time": "2019-03-05T02:56:14.059864Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n"
     ]
    }
   ],
   "source": [
    "# Import 所有 `math` module 底下的東西\n",
    "from math import *\n",
    "\n",
    "# 使用 `sqrt` 的時候也不需要先寫 `math`\n",
    "b=sqrt(4.0)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "不推薦原因是容易造成名稱衝突，降低可讀性和可維護性。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 資料型別"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 數值(Number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 整數int (signed integers) \n",
    "在Python 2 還是有兩種整數型別：整數 int 長整數 long。但在 Python 3 就沒有分了，Python 3 的 int 是unlimited size。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:14.419198Z",
     "start_time": "2019-03-05T02:56:14.403575Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35\n",
      "2575\n",
      "31\n"
     ]
    }
   ],
   "source": [
    "#用十進位賦值\n",
    "num1=35\n",
    "print(num1)\n",
    "#用Hexa-decimal賦值\n",
    "num2=0xA0F\n",
    "print(num2)\n",
    "#用Octal賦值\n",
    "num3=0o37\n",
    "print(num3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 浮點數 float (floating point real values)\n",
    "用4個位元組(byte)來存放的帶小數點的數值，等同於numpy提供的單精度浮點數(float32)，要注意有效位數只有6~7位，在傳統數值計算可能會用numpy提供的雙精度浮點數(float64)；在機器學習領域可能會用到numpy提供的半精度浮點數(float16)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 複數 complex (complex numbers) \n",
    "Python當中則是用「j」或是「J」來表示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:14.575433Z",
     "start_time": "2019-03-05T02:56:14.559808Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.5\n",
      "0.5\n"
     ]
    }
   ],
   "source": [
    "cx1 = 1.5+0.5j\n",
    "print( cx1.real )\n",
    "print( cx1.imag )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 布林值(Boolean)\n",
    "決定邏輯判斷，True 或 False。主要會搭配流程控制。注意在 Python 中布林值首字是大寫"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:14.653548Z",
     "start_time": "2019-03-05T02:56:14.622302Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "is_former_bigger_than_latter = 1 > 2\n",
    "print( is_former_bigger_than_latter )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 資料結構"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 字串(String)\n",
    "字串就像是一堆字元排在一起組合而成的，實際上是一種資料結構。\n",
    "\n",
    "字串使用上會使用單引號或雙引號成對包起（’， “）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:14.731669Z",
     "start_time": "2019-03-05T02:56:14.716042Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17\n",
      "Machine Learning in Material Informatics\n"
     ]
    }
   ],
   "source": [
    "str1 = 'Machine Learning '\n",
    "str2 = \"Material Informatics\"\n",
    "print( len(str1) )\n",
    "print( str1 + \"in \" + str2 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "三個引號('''，\"\"\")用來定義包含多行的字串"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:14.747288Z",
     "start_time": "2019-03-05T02:56:14.731669Z"
    }
   },
   "outputs": [],
   "source": [
    "paragraph = \"\"\"This is a paragraph. It is\n",
    "made up of multiple lines and sentences.\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "字串的內容也是不能修改的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:14.841028Z",
     "start_time": "2019-03-05T02:56:14.809780Z"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-47-2c2990916f39>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mstr3\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"hello python\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mstr3\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"H\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "str3 = \"hello python\"\n",
    "str3[0] = \"H\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 列表（List）\n",
    "列表可以說是 Python 中最基礎的一種資料結構。所謂列表指的就是一群按照順序排序的元素。\n",
    "\n",
    "陣列是一種容器，可用來儲存眾多資料。針對一個以創建的陣列，你可以隨時增加或減少其內部資料的個數，也可以修改裡面的內容。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:14.841028Z",
     "start_time": "2019-03-05T02:56:14.823Z"
    }
   },
   "outputs": [],
   "source": [
    "list_num = [1, 2, 3]\n",
    "list_length = len(list_num)\n",
    "num_sum = sum(list_num)\n",
    "\n",
    "print(list_length)\n",
    "print(num_sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "運用 [] 取值（index 從 0 開始）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:14.841028Z",
     "start_time": "2019-03-05T02:56:14.832Z"
    }
   },
   "outputs": [],
   "source": [
    "x = range(10) # [0, 1, 2, ..., 9]\n",
    "zero = x[0] # 0\n",
    "nine = x[-1] # 9\n",
    "print( zero )\n",
    "print( nine )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "切割（[起始 index, 結束 index 但不包含]）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:14.841028Z",
     "start_time": "2019-03-05T02:56:14.840Z"
    }
   },
   "outputs": [],
   "source": [
    "print(x[:3]) # [-1, 1, 2]\n",
    "print(x[3:]) # [3, 4, 5,..., 9]\n",
    "print(x[1:5]) # [1, 2, 3, 4]\n",
    "print(x[0:-1]) # [1, 2, ..., 8]\n",
    "print(x[-1:-1]) # [-1, 1, ..., 9]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "串接列表："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:14.872274Z",
     "start_time": "2019-03-05T02:56:14.856Z"
    }
   },
   "outputs": [],
   "source": [
    "x = [1, 2, 3]\n",
    "x.extend([4, 5, 6])\n",
    "print(len(x))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:14.872274Z",
     "start_time": "2019-03-05T02:56:14.862Z"
    }
   },
   "outputs": [],
   "source": [
    "x = [1, 2, 3]\n",
    "y = x + [4, 5, 6]\n",
    "\n",
    "print(len(y))\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:14.872274Z",
     "start_time": "2019-03-05T02:56:14.870Z"
    }
   },
   "outputs": [],
   "source": [
    "x = [1, 2, 3]\n",
    "x.append(0) # [1, 2, 3, 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "賦值:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:14.997261Z",
     "start_time": "2019-03-05T02:56:14.950391Z"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'int' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-48-e97d6bc7ade5>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# 指定第一個值是-1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mx\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'int' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "# 指定第一個值是-1\n",
    "x[0] = -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:14.997261Z",
     "start_time": "2019-03-05T02:56:14.972Z"
    }
   },
   "outputs": [],
   "source": [
    "#強制將'range' object轉為真正的list\n",
    "z = list(range(10))  # [0, 1, 2, ..., 9]\n",
    "zero = z[0] # 0\n",
    "print( zero )\n",
    "z[0] = -1\n",
    "print( z[0] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 元組（Tuple）\n",
    "Tuple可用來存放一組資料。\n",
    "\n",
    "這組資料的個數不限，型別也不須相同。\n",
    "\n",
    "值與值之間，要以,隔開。\n",
    "\n",
    "列表使用 []，而元組使用 ()。\n",
    "\n",
    "元組 是 immutable，也就是說宣告後不能修改。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:14.997261Z",
     "start_time": "2019-03-05T02:56:14.984Z"
    }
   },
   "outputs": [],
   "source": [
    "my_list = [1, 2]\n",
    "my_tuple = (1, 2)\n",
    "my_list[1] = 3\n",
    "\n",
    "try:\n",
    "\tmy_tuple[1] = 4\n",
    "except TypeError:\n",
    "\tprint('cannot modify a tuple')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "多重賦值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:14.997261Z",
     "start_time": "2019-03-05T02:56:14.990Z"
    }
   },
   "outputs": [],
   "source": [
    "x, y = 1, 2\n",
    "print(x,y)\n",
    "x, y = y, x # x == 2, y == 1\n",
    "print(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 字典（Dictionary）\n",
    "字典使用{}，包含鍵值與對應的值，可以快速取出對應值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:14.997261Z",
     "start_time": "2019-03-05T02:56:14.996Z"
    }
   },
   "outputs": [],
   "source": [
    "dict1 = {} # 建議寫法\n",
    "dirct2 = dict()\n",
    "grades = { 'Mark': 70, 'Jack': 40 }\n",
    "\n",
    "grades['Mark']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 運算子"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 數學運算子\n",
    "\n",
    "| 運算子    | 效果           |\n",
    "|:---------:|:--------------:|\n",
    "| `x + y`  | X加Y |\n",
    "| `x - y` | X減Y |\n",
    "| `x * y`   | X乘Y |\n",
    "| `x / y`   | X除以Y |\n",
    "| `x // y`   | X除以Y，只取整數解 |\n",
    "| `x % y`   | 求X除以Y的餘數 |\n",
    "| `x ** y \t`   | X的Y次方 |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 比較運算子\n",
    "\n",
    "| 運算子    | 效果           |\n",
    "|:---------:|:--------------:|\n",
    "| `x < y`  | X是否小於Y |\n",
    "| `x <= y` | X是否小於等於Y |\n",
    "| `x > y`   | X是否大於Y |\n",
    "| `x >= y`   | X是否大於等於Y |\n",
    "| `x == y`   | X是否等於Y |\n",
    "| `x != y`   | X是否不等於Y |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 布林運算子\n",
    "\n",
    "| 運算子    | 效果           |\n",
    "|:---------:|:--------------:|\n",
    "| `a or b`  | A或B其中一個條件成立就回傳True |\n",
    "| `a and b` | A或B兩個條件都成立才回傳True |\n",
    "| `not a`   | 如果A為True，則回傳False，反之則回傳True |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-05T02:56:15.012886Z",
     "start_time": "2019-03-05T02:56:15.015Z"
    }
   },
   "outputs": [],
   "source": [
    "h = 180\n",
    "w = 85\n",
    "grade = 80\n",
    "\n",
    "# 身高超過175或是體重超過80，看起來就很大隻\n",
    "if h > 175 or w > 80:\n",
    "    print('big dude')\n",
    "\n",
    "# 成績高於70但是不高於90，就是個普通學生\n",
    "if grade > 70 and grade < 90:\n",
    "    print('noraml')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 控制流程"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## if…elif…else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## while"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.2"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}