Python3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python3 基礎語法\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Basic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.1 基本概念"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Python中，萬物皆為對象(Object)\n",
    "* 每個對象包含3種屬性 : id (位址) / type (類型) / value (數值)\n",
    "* python 原始碼文件預設編碼 : UTF-8\n",
    "* 字符串皆為 unicode 字符串"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#指定不同編碼\n",
    "# -*- coding: cp-1252 -*-\n",
    "# -*- coding: UTF-8 -*-\n",
    "#coding=utf-8 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.2 註解"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 單行註解以 # 開頭\n",
    "* 多行註解以''' 或 \"\"\" 開頭及結尾"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'\\na=a+b\\n我是註解 1\\n我是註解 2\\n#print(\"Hello Nick\")\\n'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#我是註解 \n",
    "print(\"Hello world\")\n",
    "\n",
    "a = 1\n",
    "b = 2\n",
    "\n",
    "'''\n",
    "print(a+b)\n",
    "'''\n",
    "\"\"\"\n",
    "a=a+b\n",
    "我是註解 1\n",
    "我是註解 2\n",
    "#print(\"Hello Nick\")\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  1.3. 行與縮排"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 以\"縮排\" 取代 \"{ }\", 作為程式碼區域\n",
    "* 區域內縮排不一致,將導致運行錯誤"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "Apple\n"
     ]
    }
   ],
   "source": [
    "if True:\n",
    "    print (\"True\")\n",
    "    print (\"Apple\")\n",
    "else:\n",
    "    print (\"False\")\n",
    "    print (\"Cat\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.4. 變數命名規則"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 保留字不得做為變數名稱\n",
    "* 變數起始字母需為\"英文字母\" 或 \"_\"\n",
    "* 變數大小寫視為不同變數"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['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": [
    "# 保留字\n",
    "import keyword\n",
    "print(keyword.kwlist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "## 變數大小寫視為不同變數\n",
    "a=1\n",
    "A=2\n",
    "\n",
    "print(a)\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.5.  比較運算符號"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "運算符號 | 說明 \n",
    "------|------ \n",
    "== | 等於 \n",
    "!= | 不等於 \n",
    "> | 大於\n",
    "< | 小於\n",
    ">= | 大於等於\n",
    "<= | 小於等於"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.6.  賦值運算符號"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "運算符號 | 說明 \n",
    "------|------ \n",
    "= | a = b + c\n",
    "+= | a = a + b\n",
    "-= | a = a - b\n",
    "*= | a = a * b\n",
    "/= | a = a / b\n",
    "%= | a = a % b\n",
    "**= | a = a ** b\n",
    "//= | a = a // b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.7.  身份(id) 運算符號 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* is  \n",
    "* is not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "4299438688\n",
      "4299438688\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "a = 20\n",
    "b = 20\n",
    "\n",
    "print(a is b)\n",
    "print(id(a)) #id()取得 變數位址\n",
    "print(id(b))\n",
    "print(a is not b)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "4329831728\n",
      "4329831952\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# 在python 互動式界面有記憶體緩存機制，範圍-5~256\n",
    "\n",
    "a = 257\n",
    "b = 257\n",
    "\n",
    "print(a is b)\n",
    "print(id(a)) #id()取得 變數位址\n",
    "print(id(b))\n",
    "print(a is not b)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* is : 判斷變數位址是否相同\n",
    "* == : 判斷變數數值是否相同"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a=257\n",
    "b=257\n",
    "\n",
    "print(a is b)\n",
    "print(a is not b)\n",
    "print(a == b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. 變數類型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1 數字 (Number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#整數\n",
    "a = 10\n",
    "print(type(a))\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 浮點數\n",
    "b = 2.5\n",
    "type(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.5 0.5\n"
     ]
    }
   ],
   "source": [
    "# 複數\n",
    "c = 1.5+0.5j\n",
    "print(c.real,c.imag) # 輸出var.real 複數中的實數, var.imag 複數中的虛數 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a+b =  30\n",
      "a-b =  10\n",
      "a*b =  200\n",
      "a/b =  2.0 <class 'float'>\n",
      "a//b =  2 <class 'int'>\n",
      "a%b =  0 <class 'int'>\n",
      "a**b =  10240000000000 <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "a = 20\n",
    "b = 10\n",
    "print (\"a+b = \" , a+b)  # 加法\n",
    "print (\"a-b = \" , a-b)  # 減法\n",
    "print (\"a*b = \" , a*b)  # 乘法a\n",
    "print (\"a/b = \" , a/b, type(a/b))  # 除法\n",
    "print (\"a//b = \", a//b, type(a//b)) # 取1d整數\n",
    "print (\"a%b = \", a%b, type(a%b)) # 取餘數\n",
    "print (\"a**b = \", a**b, type(a**b)) # 乘方"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.2 字串 (String)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 單引號（'）或雙引號（\"）包起來的資料都是字串"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'm Nick\n",
      "I'm Nick\n"
     ]
    }
   ],
   "source": [
    "strA ='I\\'m Nick'\n",
    "strB = \"I\\'m Nick\"\n",
    "print(strA)\n",
    "print(strB)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!I'm Ncik\n"
     ]
    }
   ],
   "source": [
    "#字串連接 (+)\n",
    "strA = 'Hello World!'\n",
    "strB = 'I\\'m Ncik' # I'm Nick\n",
    "print(strA + strB)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!Hello World!\n"
     ]
    }
   ],
   "source": [
    "#重覆字串 (*)\n",
    "print(strA * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "o\n",
      "Hel\n"
     ]
    }
   ],
   "source": [
    "#取得字串中第i個字符 var[idx]\n",
    "print(strA[4])\n",
    "\n",
    "#取得字串中某一段字符 var[:]\n",
    "print(strA[0:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#判斷某字符或字串是否在字串中 (in)\n",
    "print (\"Hello\" in strA)\n",
    "\n",
    "#判斷某字符或字串是否不在字串中 (not in)\n",
    "print (\"W\" not in strA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i have 5 bananas.\n"
     ]
    }
   ],
   "source": [
    "#print時字串,數字串接\n",
    "a=5\n",
    "b='bananas'\n",
    "print('i have %d %s.' %(a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "#將字串中第一個字母轉為大寫 str.capitalize()\n",
    "strA = \"hello\"\n",
    "print(strA.capitalize()) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "strA = \"hello\"\n",
    "# 回傳某字元或字串在原字串中的次數\n",
    "print(strA.count('e'))\n",
    "print(strA.count('e',0,2)) # position : 0~2  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "strA = \"hello\"\n",
    "# 回傳字串長度\n",
    "print(len(strA))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "o\n",
      "e\n"
     ]
    }
   ],
   "source": [
    "strA = \"hello\"\n",
    "#回傳字串中最大的字元\n",
    "print(max(strA))\n",
    "\n",
    "#回傳字串中最小的字元\n",
    "print(min(strA))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "heaao\n",
      "healo\n"
     ]
    }
   ],
   "source": [
    "strA = \"hello\"\n",
    "#字串取代\n",
    "print(strA.replace(\"l\",\"a\"))\n",
    "print(strA.replace(\"l\",\"a\",1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--hello---\n"
     ]
    }
   ],
   "source": [
    "strA = \"hello\"\n",
    "#回傳一個以原字串置中的字串\n",
    "print(strA.center(10,'-'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# 判斷字串是否以英文字母或數字組成 , 回傳True / False\n",
    "strA = \"hello!123\"\n",
    "print(strA.isalnum())\n",
    "\n",
    "strA = \"hello123\"\n",
    "print(strA.isalnum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "#判斷字串組成是否為數字\n",
    "strA=\"1231231\"\n",
    "print(strA.isdigit())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.3 串列 (List)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* list = [] \n",
    "* 由一連串順序性的元素組成，可新增、讀取、刪除和修改串列，串列中可有重複的元素"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[] <class 'list'>\n",
      "[] <class 'list'>\n",
      "[1, 2, 3, 4, 5, 6] <class 'list'>\n",
      "['Apple', 'Bee', 'Cat', 'Dog'] <class 'list'>\n",
      "['Apple', 123, 'Bee', 456] <class 'list'>\n"
     ]
    }
   ],
   "source": [
    "listA =[]\n",
    "listB = list()\n",
    "listC = [1,2,3,4,5,6]\n",
    "listD = [\"Apple\",\"Bee\",\"Cat\",\"Dog\"]\n",
    "listE = [\"Apple\",123,\"Bee\",456]\n",
    "print(listA , type(listA))\n",
    "print(listB , type(listB))\n",
    "print(listC , type(listC))\n",
    "print(listD , type(listD))\n",
    "print(listE , type(listE))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* var[index] : 回傳list中特定位置元素\n",
    "* var[start:end]： 回傳list中特定範圍的元素"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "9\n",
      "[1, 3, 5]\n"
     ]
    }
   ],
   "source": [
    "listA = [1,3,5,7,9]\n",
    "print(listA[0])\n",
    "print(listA[-1])\n",
    "print(listA[0:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "# 回傳List元素個數 len(var)\n",
    "listA = [\"Apple\",123,\"Bee\",456]\n",
    "print(len(listA))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "99\n",
      "1\n",
      "Dog\n",
      "Apple\n"
     ]
    }
   ],
   "source": [
    "listA =[5,2,99,1]\n",
    "listB =[\"Apple\",\"Bee\",\"Cat\",\"Dog\"]\n",
    "\n",
    "#max() : 回傳List中最大的元素\n",
    "#min() : 回傳List中最小的元素\n",
    "\n",
    "print(max(listA)) #　List中的元素需為相同型態\n",
    "print(min(listA)) #　List中的元素需為相同型態\n",
    "\n",
    "print(max(listB)) #　List中的元素需為相同型態\n",
    "print(min(listB)) #　List中的元素需為相同型態"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['H', 'e', 'l', 'l', 'o']\n"
     ]
    }
   ],
   "source": [
    "# list() : 將Tuple, String 轉化為List\n",
    "\n",
    "strC =\"Hello\"\n",
    "print(list(strC))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Apple', 'Bee', 'Cat', 'Dog', 'Elephant']\n"
     ]
    }
   ],
   "source": [
    "# append() : 新增list 元素\n",
    "listA =[\"Apple\",\"Bee\",\"Cat\",\"Dog\"]\n",
    "listA.append(\"Elephant\")\n",
    "print(listA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Apple', 'Air', 'Bee', 'Cat', 'Dog']\n"
     ]
    }
   ],
   "source": [
    "#insert(index,obj) : 新增某元素至list中特定位置\n",
    "listA =[\"Apple\",\"Bee\",\"Cat\",\"Dog\"]\n",
    "listA.insert(1,\"Air\")\n",
    "print(listA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Apple', 'Bee', 'Dog', 'Elephant']\n"
     ]
    }
   ],
   "source": [
    "#remove() : 移除list 中特定元素\n",
    "listA = ['Apple', 'Bee', 'Cat', 'Dog', 'Elephant']\n",
    "listA.remove(\"Cat\")\n",
    "print(listA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Apple', 'Bee', 'Cat', 'Dog']\n"
     ]
    }
   ],
   "source": [
    "# pop() : 移除list中最後一個元素\n",
    "listA = ['Apple', 'Bee', 'Cat', 'Dog', 'Elephant']\n",
    "listA.pop()\n",
    "print(listA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Apple', 'Bee', 'Cat', 'Dog', 'Elephant']\n",
      "[1, 2, 5, 80, 99]\n"
     ]
    }
   ],
   "source": [
    "#sort() : 將list進行排序\n",
    "listA = ['Apple', 'Elephant', 'Bee', 'Dog', 'Cat' ]\n",
    "listA.sort()\n",
    "print(listA)\n",
    "\n",
    "listB = [99, 2, 1, 80, 5 ]\n",
    "listB.sort()\n",
    "print(listB)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Cat', 'Dog', 'Bee', 'Elephant', 'Apple']\n",
      "[5, 80, 1, 2, 99]\n"
     ]
    }
   ],
   "source": [
    "#reverse() : 將list反向\n",
    "listA = ['Apple', 'Elephant', 'Bee', 'Dog', 'Cat' ]\n",
    "listA.reverse()\n",
    "print(listA)\n",
    "\n",
    "listB = [99, 2, 1, 80, 5 ]\n",
    "listB.reverse()\n",
    "print(listB)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Apple', 'Elephant', 'Bee', 'D', 'o', 'g']\n",
      "['Apple', 'Elephant', 'Bee', 'D', 'o', 'g', 'Cat', 'Panda']\n"
     ]
    }
   ],
   "source": [
    "# 串列連接\n",
    "listA = ['Apple', 'Elephant', 'Bee']\n",
    "\n",
    "listA.extend( 'Dog')\n",
    "print(listA)\n",
    "\n",
    "listA += ['Cat', 'Panda'] \n",
    "print(listA)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Apple', 'Elephant']\n"
     ]
    }
   ],
   "source": [
    "# del 刪除特定 index 值\n",
    "\n",
    "listA = ['Apple', 'Elephant', 'Bee']\n",
    "\n",
    "del listA[-1]\n",
    "print(listA)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# in , not in 檢查元素是否在串列\n",
    "listA = ['Apple', 'Elephant', 'Bee']\n",
    "print(\"Cat\" in listA)\n",
    "print(\"Bee\" in listA)\n",
    "\n",
    "print(\"Cat\" not in listA)\n",
    "print(\"Bee\" not in listA)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.4 元組 (Tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* tuple = ()\n",
    "* 與list相似,但無法更改元素\n",
    "* 佔用空間較少\n",
    "* 可以當做字典的 key（因不可變）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tup1 = ()\n",
    "#tup2 = (50)\n",
    "tup2 = (50,)\n",
    "#type(tup2)\n",
    "tup3 = ('Dog', 'cat', 1997, 2000)\n",
    "tup4 = (1, 2, 3, 4, 5 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tup3[0]: Dog\n",
      "tup4[1:5]: (2, 3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "print (\"tup3[0]:\", tup3[0])\n",
    "print (\"tup4[1:5]:\", tup4[1:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-43-df55fdce26d6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtup3\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "tup3[0]=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Dog', 'cat', 1997, 2000, 1, 2, 3, 4, 5)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tup5 = tup3 + tup4\n",
    "tup5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "del tup3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#計算Tuple中元素數目\n",
    "\n",
    "len((1, 2, 3, 4, 5 ,7,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#回傳Tuple中最大的元素\n",
    "\n",
    "max((1, 2, 3, 4, 5 ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#回傳Tuple中最小的元素\n",
    "min((1, 2, 3, 4, 5 ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.5 字典 (Dictionary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* dict = { key1 : value1, key2 : value2 }\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict['Course']:  計算機概論\n",
      "dict['Credit']:  2\n"
     ]
    },
    {
     "ename": "KeyError",
     "evalue": "'Number'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-49-d825f737b988>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"dict['Credit']: \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Credit'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"dict['Credit']: \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Number'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 'Number'"
     ]
    }
   ],
   "source": [
    "dict ={}\n",
    "dict = {'Course': '計算機概論', 'Teacher': 'Nick', 'Class': '1A', 'Credit' :2}\n",
    "print (\"dict['Course']: \", dict['Course'])\n",
    "print (\"dict['Credit']: \", dict['Credit'])\n",
    "\n",
    "print (\"dict['Credit']: \", dict['Number'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Course': '計算機概論', 'Teacher': 'David', 'Class': '1A', 'Credit': 2, 'Department': '資管系'}\n"
     ]
    }
   ],
   "source": [
    "# 更新字典\n",
    "dict = {'Course': '計算機概論', 'Teacher': 'Nick', 'Class': '1A', 'Credit' :2}\n",
    "\n",
    "dict['Teacher'] = 'David'\n",
    "dict['Department'] = '資管系'\n",
    "print (dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'php', 'version': '7.2'}\n",
      "{'name': 'php', 'version': '7.2'}\n"
     ]
    }
   ],
   "source": [
    "dict1 = {\n",
    "    'name': 'python',\n",
    "    'version': '3.5'\n",
    "}\n",
    "\n",
    "dict2 = {\n",
    "    'name': 'php',\n",
    "    'version': '7.2'\n",
    "}\n",
    "\n",
    "dict1.update(dict2)\n",
    "print(dict1)\n",
    "print(dict2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Credit': 2, 'Course': '計算機概論', 'Teacher': 'David', 'Class': '1A'}\n",
      "{}\n"
     ]
    }
   ],
   "source": [
    "dict = {'Credit': 2, 'Course': '計算機概論', 'Department': '資管系', 'Teacher': 'David', 'Class': '1A'}\n",
    "\n",
    "# 删除字典 / 元素\n",
    "del dict['Department'];\n",
    "print(dict)\n",
    "\n",
    "# 清空字典內所有元素\n",
    "dict.clear() \n",
    "print(dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#計算字典個素 len()\n",
    "dict1 = {'Course': '計算機概論', 'Teacher': 'Nick', 'Class': '1A', 'Credit' :2}\n",
    "len(dict1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 判斷字典是否有某鍵值\n",
    "dict1 = {'Course': '計算機概論', 'Teacher': 'Nick', 'Class': '1A', 'Credit' :2}\n",
    "dict1.__contains__('Course')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['Course', 'Teacher', 'Class', 'Credit'])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#顯示字典所有鍵值\n",
    "dict1 = {'Course': '計算機概論', 'Teacher': 'Nick', 'Class': '1A', 'Credit' :2}\n",
    "dict1.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['計算機概論', 'Nick', '1A', 2])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#顯示字典所有值\n",
    "dict1 = {'Course': '計算機概論', 'Teacher': 'Nick', 'Class': '1A', 'Credit' :2}\n",
    "dict1.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Class': '1A', 'Course': '計算機概論', 'Teacher': 'Nick'}"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#隨機pop一個鍵值\n",
    "dict1 = {'Course': '計算機概論', 'Teacher': 'Nick', 'Class': '1A', 'Credit' :2}\n",
    "dict1.popitem() # 隨機pop一個鍵值\n",
    "dict1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Class': '1A', 'Course': '計算機概論', 'Credit': 2}"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# pop某一個key\n",
    "dict1 = {'Course': '計算機概論', 'Teacher': 'Nick', 'Class': '1A', 'Credit' :2}\n",
    "dict1.pop('Teacher') # pop某一個key\n",
    "dict1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.6 集合 (Set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 類似數學集合"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animals = set()\n",
    "\n",
    "animals= {'cat', 'dog', 'bee', 'panda'}\n",
    "animals\n",
    "type(animals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'c', 'a', 't'}\n",
      "{'bee', 'dog'}\n",
      "{'cat', 'panda'}\n"
     ]
    }
   ],
   "source": [
    "print(set('cat'))\n",
    "print(set(['dog', 'bee']))\n",
    "print(set(('panda', 'cat')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'cat', 'panda'}\n",
      "{'ant', 'panda', 'bee', 'dog', 'cat', 'bird'}\n",
      "{'bee', 'dog'}\n"
     ]
    }
   ],
   "source": [
    "animals1 = {'cat', 'dog', 'bee', 'panda'}\n",
    "animals2 = {'cat', 'ant', 'bird', 'panda'}\n",
    "print(animals1.intersection(animals2)) \n",
    "print(animals1.union(animals2)) \n",
    "print(animals1.difference(animals2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. 條件控制 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 3.1 IF ....ELSE "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ByeBye\n"
     ]
    }
   ],
   "source": [
    "sex = 'F'\n",
    " \n",
    "if sex == 'M' :\n",
    "    print(\"Hello\")\n",
    "\n",
    "else:\n",
    "    print(\"ByeBye\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ByeBye\n"
     ]
    }
   ],
   "source": [
    "# m if m > n else n\n",
    "\n",
    "print(\"Hello\") if sex == 'M' else print(\"ByeBye\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 3.2 IF ....ELIF.....ELSE... \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "猜數字遊戲\n",
      "請輸入猜的數字：5\n",
      "猜的數字太小...\n"
     ]
    }
   ],
   "source": [
    "number = 35\n",
    "print(\"猜數字遊戲\")\n",
    "\n",
    "guess = int(input(\"請輸入猜的數字：\"))\n",
    " \n",
    "if guess == number:\n",
    "    print(\"猜對了!!\")\n",
    "elif guess < number:\n",
    "    print(\"猜的數字太小...\")\n",
    "else:\n",
    "    print(\"猜的數字太大...\")\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D\n",
      "C\n"
     ]
    }
   ],
   "source": [
    "#巢狀if else迴圈\n",
    "\n",
    "score=85\n",
    "\n",
    "if(score>60):    \n",
    "    if(score>60 and score<=70):       \n",
    "        print(\"F\")    \n",
    "    elif(score>70 and score<=80):        \n",
    "        print(\"E\")    \n",
    "    elif(score>80 and score<=90):       \n",
    "        print(\"D\")       \n",
    "        if(score==85):           \n",
    "            print(\"C\")    \n",
    "    else:       \n",
    "        print(\"A\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. 循環控制 For loop & While loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.1 For loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# for(int i=0 ; i<10 ; i++)\n",
    "# {\n",
    "#    print(\"%d\",i)\n",
    "# }\n",
    "\n",
    "for i in range(1,10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 x 1 = 1\n",
      "1 x 2 = 2\n",
      "1 x 3 = 3\n",
      "1 x 4 = 4\n",
      "1 x 5 = 5\n",
      "1 x 6 = 6\n",
      "1 x 7 = 7\n",
      "1 x 8 = 8\n",
      "1 x 9 = 9\n",
      "2 x 1 = 2\n",
      "2 x 2 = 4\n",
      "2 x 3 = 6\n",
      "2 x 4 = 8\n",
      "2 x 5 = 10\n",
      "2 x 6 = 12\n",
      "2 x 7 = 14\n",
      "2 x 8 = 16\n",
      "2 x 9 = 18\n",
      "3 x 1 = 3\n",
      "3 x 2 = 6\n",
      "3 x 3 = 9\n",
      "3 x 4 = 12\n",
      "3 x 5 = 15\n",
      "3 x 6 = 18\n",
      "3 x 7 = 21\n",
      "3 x 8 = 24\n",
      "3 x 9 = 27\n",
      "4 x 1 = 4\n",
      "4 x 2 = 8\n",
      "4 x 3 = 12\n",
      "4 x 4 = 16\n",
      "4 x 5 = 20\n",
      "4 x 6 = 24\n",
      "4 x 7 = 28\n",
      "4 x 8 = 32\n",
      "4 x 9 = 36\n",
      "5 x 1 = 5\n",
      "5 x 2 = 10\n",
      "5 x 3 = 15\n",
      "5 x 4 = 20\n",
      "5 x 5 = 25\n",
      "5 x 6 = 30\n",
      "5 x 7 = 35\n",
      "5 x 8 = 40\n",
      "5 x 9 = 45\n",
      "6 x 1 = 6\n",
      "6 x 2 = 12\n",
      "6 x 3 = 18\n",
      "6 x 4 = 24\n",
      "6 x 5 = 30\n",
      "6 x 6 = 36\n",
      "6 x 7 = 42\n",
      "6 x 8 = 48\n",
      "6 x 9 = 54\n",
      "7 x 1 = 7\n",
      "7 x 2 = 14\n",
      "7 x 3 = 21\n",
      "7 x 4 = 28\n",
      "7 x 5 = 35\n",
      "7 x 6 = 42\n",
      "7 x 7 = 49\n",
      "7 x 8 = 56\n",
      "7 x 9 = 63\n",
      "8 x 1 = 8\n",
      "8 x 2 = 16\n",
      "8 x 3 = 24\n",
      "8 x 4 = 32\n",
      "8 x 5 = 40\n",
      "8 x 6 = 48\n",
      "8 x 7 = 56\n",
      "8 x 8 = 64\n",
      "8 x 9 = 72\n",
      "9 x 1 = 9\n",
      "9 x 2 = 18\n",
      "9 x 3 = 27\n",
      "9 x 4 = 36\n",
      "9 x 5 = 45\n",
      "9 x 6 = 54\n",
      "9 x 7 = 63\n",
      "9 x 8 = 72\n",
      "9 x 9 = 81\n"
     ]
    }
   ],
   "source": [
    "# for(int i=0 ; i<10 ; i++)\n",
    "# {\n",
    "#   for(int i=0 ; i<10 ; i++)\n",
    "#    {\n",
    "#         printf(\"%d x %d = %d\",i,j,i*j); \n",
    "#    }   \n",
    "# }\n",
    "\n",
    "for i in range(1,10):\n",
    "    for j in range(1,10):\n",
    "        print(\"%d x %d = %d\" %(i,j,i*j))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "200\n",
      "300\n",
      "400\n",
      "500\n",
      "600\n",
      "700\n"
     ]
    }
   ],
   "source": [
    "listA = [100,200,300,400,500,600,700]\n",
    "\n",
    "for item in listA:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "index = 0 , value = 100 \n",
      "index = 1 , value = 200 \n",
      "index = 2 , value = 300 \n",
      "index = 3 , value = 400 \n",
      "index = 4 , value = 500 \n",
      "index = 5 , value = 600 \n",
      "index = 6 , value = 700 \n"
     ]
    }
   ],
   "source": [
    "listA = [100,200,300,400,500,600,700]\n",
    "i = 0\n",
    "for item in listA:\n",
    "    print(\"index = %d , value = %d \"%(i,item))\n",
    "    i+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0, 100), (1, 200), (2, 300), (3, 400), (4, 500), (5, 600), (6, 700)]\n",
      "index = 0 , value = 100 \n",
      "index = 1 , value = 200 \n",
      "index = 2 , value = 300 \n",
      "index = 3 , value = 400 \n",
      "index = 4 , value = 500 \n",
      "index = 5 , value = 600 \n",
      "index = 6 , value = 700 \n"
     ]
    }
   ],
   "source": [
    "listA = [100,200,300,400,500,600,700]\n",
    "\n",
    "print(list(enumerate(listA)))\n",
    "for idx, val in enumerate(listA):\n",
    "    print(\"index = %d , value = %d \"%(idx,val))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.2 While loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0  < 8\n",
      "1  < 8\n",
      "2  < 8\n",
      "3  < 8\n",
      "4  < 8\n",
      "5  < 8\n",
      "6  < 8\n",
      "7  < 8\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "while count < 8:\n",
    "    print (count, \" < 8\")\n",
    "    count += 1 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0  < 5\n",
      "1  < 5\n",
      "2  < 5\n",
      "3  < 5\n",
      "4  < 5\n",
      "5  >= 5\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "while count < 5:\n",
    "    print (count, \" < 5\")\n",
    "    count = count + 1\n",
    "else:\n",
    "    print (count, \" >= 5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.3 Break,Continue,Pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<B>* break : 用来終止迴圈</B>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p\n",
      "y\n",
      "t\n"
     ]
    }
   ],
   "source": [
    "for letter in 'python': \n",
    "    if letter == 'h':\n",
    "        break\n",
    "    print(letter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "貓咪\n",
      "Loop Finish!\n"
     ]
    }
   ],
   "source": [
    "animals = [\"Cat\", \"Dog\",\"Bird\",\"Panda\"]\n",
    "for animal in animals:\n",
    "    if animal == \"Cat\":\n",
    "        print(\"貓咪\")\n",
    "        break\n",
    "        print(\"data \" + animal)\n",
    "    else:\n",
    "        print(\"data \" + animal)\n",
    "\n",
    "print(\"Loop Finish!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<B>* continue : 用来跳脫本次迴圈</B>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p\n",
      "y\n",
      "t\n",
      "o\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "for letter in 'python': \n",
    "    if letter == 'h':\n",
    "        continue\n",
    "    print(letter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "貓咪\n",
      "data Dog\n",
      "data Bird\n",
      "data Panda\n",
      "Loop Finish!\n"
     ]
    }
   ],
   "source": [
    "animals = [\"Cat\", \"Dog\",\"Bird\",\"Panda\"]\n",
    "for animal in animals:\n",
    "    if animal == \"Cat\":\n",
    "        print(\"貓咪\")\n",
    "        continue\n",
    "        print(\"data \" + animal)\n",
    "    else:\n",
    "        print(\"data \" + animal)\n",
    "\n",
    "print(\"Loop Finish!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<B>* pass : 不做任何事情為空语句，主要是為保持程式結構完整性</B>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p\n",
      "y\n",
      "t\n",
      "h\n",
      "o\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "for letter in 'python': \n",
    "    if letter == 'h':\n",
    "        pass\n",
    "    print(letter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "貓咪\n",
      "data Cat\n",
      "data Dog\n",
      "data Bird\n",
      "data Panda\n",
      "Loop Finish!\n"
     ]
    }
   ],
   "source": [
    "animals = [\"Cat\", \"Dog\",\"Bird\",\"Panda\"]\n",
    "for animal in animals:\n",
    "    if animal == \"Cat\":\n",
    "        print(\"貓咪\")\n",
    "        pass\n",
    "        print(\"data \" + animal)\n",
    "    else:\n",
    "        print(\"data \" + animal)\n",
    "\n",
    "print(\"Loop Finish!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. 函數"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.1 自建函數"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "def hello() :\n",
    "    print(\"Hello World!\")\n",
    "\n",
    "hello()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.2 自建函數(傳遞參數)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'm Nick !\n"
     ]
    }
   ],
   "source": [
    "def printme( str ):\n",
    "    print (str)\n",
    "\n",
    "printme(\"I'm Nick !\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am David\n",
      "I am Nick\n"
     ]
    }
   ],
   "source": [
    "# Default Parameter Value\n",
    "\n",
    "def printme( name = 'Nick'):\n",
    "    print (\"I am \" + name)\n",
    "    \n",
    "\n",
    "printme(\"David\")\n",
    "printme()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.3 全域變數"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "123\n",
      "123\n"
     ]
    }
   ],
   "source": [
    "num = 10\n",
    "def functionA():\n",
    "    global num \n",
    "    print(num) \n",
    "    num = 123\n",
    "    print(num)\n",
    "functionA()\n",
    "print(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.4 回傳值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "def functionA(x):\n",
    "    return 10 * x\n",
    "\n",
    "print(functionA(1))\n",
    "print(functionA(2))\n",
    "print(functionA(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def functionA(x):\n",
    "    return True if x >15 else False\n",
    "\n",
    "print(functionA(10))\n",
    "print(functionA(20))\n",
    "print(functionA(30))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.5 lambda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n"
     ]
    }
   ],
   "source": [
    "def functionA(a,b):\n",
    "    return a + b + 10\n",
    "\n",
    "print(functionA(5,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n"
     ]
    }
   ],
   "source": [
    "x = lambda a,b : a + b + 10\n",
    "print(x(5,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "def functionA(a,b):\n",
    "    return a if a >b else b\n",
    "\n",
    "print(functionA(5,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "x = lambda a,b : a if a >b else b\n",
    "print(x(5,10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. 類別 (Class) & 物件 (Object)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6.1 建立類別"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    x = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6.2 建立物件"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "A = MyClass()\n",
    "\n",
    "print(A.x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John\n",
      "36\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age):  ##物件建立之後所要建立的初始化動作\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "p1 = Person(\"John\", 36)\n",
    "\n",
    "print(p1.name)\n",
    "print(p1.age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. Module 模組"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.1 import module\n",
    "import module1[, module2[,... moduleN]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import support"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello,   Nick\n"
     ]
    }
   ],
   "source": [
    "support.print_func(\"Nick\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "support.add_func(30,20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "support.sub_func(20,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.2 from … import\n",
    "from modname import name1[, name2[, ... nameN]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from support import add_func\n",
    "add_func(10,20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n",
      "-10\n"
     ]
    }
   ],
   "source": [
    "from support import add_func as add ,sub_func as sub\n",
    "print(add(10,20))\n",
    "print(sub(10,20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8. FILE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Artificial intelligence (AI), sometimes called machine intelligence, is intelligence demonstrated by machines, in contrast to the natural intelligence displayed by humans and other animals. \n",
      "In computer science AI research is defined as the study of \"intelligent agents\": any device that perceives its environment and takes actions that maximize its chance of successfully achieving its goals.[1] Colloquially, the term \"artificial intelligence\" is applied when a machine mimics \"cognitive\" functions that humans associate with other human minds, such as \"learning\" and \"problem solving\"\n"
     ]
    }
   ],
   "source": [
    "# 讀取檔案\n",
    "\n",
    "f = open(\"data/AI.txt\", \"r\")\n",
    "print(f.read())\n",
    "#print(f.read(5))\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Artificial intelligence (AI), sometimes called machine intelligence, is intelligence demonstrated by machines, in contrast to the natural intelligence displayed by humans and other animals. \n",
      "\n"
     ]
    }
   ],
   "source": [
    "f = open(\"data/AI.txt\", \"r\")\n",
    "print(f.readline())\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Artificial intelligence (AI), sometimes called machine intelligence, is intelligence demonstrated by machines, in contrast to the natural intelligence displayed by humans and other animals. \n",
      "\n",
      "In computer science AI research is defined as the study of \"intelligent agents\": any device that perceives its environment and takes actions that maximize its chance of successfully achieving its goals.[1] Colloquially, the term \"artificial intelligence\" is applied when a machine mimics \"cognitive\" functions that humans associate with other human minds, such as \"learning\" and \"problem solving\"\n"
     ]
    }
   ],
   "source": [
    "f = open(\"data/AI.txt\", \"r\")\n",
    "for x in f:\n",
    "    print(x)\n",
    "    \n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Artificial intelligence (AI), sometimes called machine intelligence, is intelligence demonstrated by machines, in contrast to the natural intelligence displayed by humans and other animals. \n",
      "In computer science AI research is defined as the study of \"intelligent agents\": any device that perceives its environment and takes actions that maximize its chance of successfully achieving its goals.[1] Colloquially, the term \"artificial intelligence\" is applied when a machine mimics \"cognitive\" functions that humans associate with other human minds, such as \"learning\" and \"problem solving\"\n"
     ]
    }
   ],
   "source": [
    "# 避免檔案讀寫時造成IO ERROR , 無法關閉檔案\n",
    "try:\n",
    "    f = open(\"data/AI.txt\", \"r\")\n",
    "    print(f.read())\n",
    "finally:\n",
    "    if f:\n",
    "        f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Artificial intelligence (AI), sometimes called machine intelligence, is intelligence demonstrated by machines, in contrast to the natural intelligence displayed by humans and other animals. \n",
      "In computer science AI research is defined as the study of \"intelligent agents\": any device that perceives its environment and takes actions that maximize its chance of successfully achieving its goals.[1] Colloquially, the term \"artificial intelligence\" is applied when a machine mimics \"cognitive\" functions that humans associate with other human minds, such as \"learning\" and \"problem solving\"\n"
     ]
    }
   ],
   "source": [
    "with open(\"data/AI.txt\", \"r\") as f:\n",
    "    print(f.read())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "# 寫入檔案\n",
    "\n",
    "#清空檔案內容，新寫入的東西可在讀出(檔案可不存在，會自行新增)\n",
    "with open(\"data/demoA.txt\", \"w\") as f:\n",
    "    print(f.write(\"Hello\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "#新寫入內容加在原內容末端(檔案可不存在，會自行新增)\n",
    "with open(\"data/demoB.txt\", \"a+\") as f:\n",
    "    print(f.write(\"Hi\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9. OS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/Users/lirt/workspace/1029_python/MIRLE1029-master/new'"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#取得當前目錄路徑\n",
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['support.py',\n",
       " 'DataAnalysis-Copy1.ipynb',\n",
       " 'test',\n",
       " '__pycache__',\n",
       " 'Database-Copy1.ipynb',\n",
       " 'Python3-Copy1.ipynb',\n",
       " '.ipynb_checkpoints',\n",
       " 'data',\n",
       " 'Web-Copy1.ipynb']"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#列出某路徑資料夾底下所有檔案清單\n",
    "#os.listdir(\"~/\")\n",
    "os.listdir(os.getcwd())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#新增資料夾\n",
    "os.mkdir(\"Example\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 以遞迴方式新增資料夾\n",
    "os.makedirs(\"Example/A/B/C\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#刪除特定資料夾\n",
    "os.rmdir(\"Example/A/B/C\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#以遞迴方式刪除資料夾\n",
    "os.removedirs(\"Example/A/B\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 修改資料夾名稱\n",
    "os.mkdir(\"Example\")\n",
    "os.rename('Example','test')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}