{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "

\n", " \n", " Open In Jupyter nbviewer\n", " \n", " \n", "

" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/twMr7/Python-Machine-Learning/blob/master/02-Syntax_Overview_1.ipynb)\n", "\n", "# 2. 語法概要（上） Syntax Overview 1\n", "\n", "程式語言的核心任務，主要就是數值的運算或對資料的操作。本章首先針對常用的資料、容器類型以及基本的操作方式作概觀性的介紹：\n", "\n", "+ [**2.1 資料型別（Data types）**](#object-types)\n", "+ [**2.2 操作運算子（Operators）**](#operators)\n", "+ [**2.3 變數與物件（Variable and Object）**](#variable-and-object)\n", "+ [**2.4 序列容器的操作（Sequence Operations）**](#sequence-operations)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## 2.1 資料型別 Data Types\n", "\n", "對 Python 來說，程式碼裡操作的所有東西都是物件（Object），所以比較正確的來說，我們會介紹的是 Python 裡的物件型別（Object types）。Python常用的內建物件包含了**數值**（Number）、**序列**（Sequence）、**集合**（Set）、**對應集**（Mapping）資料型別，以及**檔案**和**None**等物件。主要的資料型別裡，有的物件型別的資料內容可以就地變更（Mutable），有的不能就地變更（Immutable），常用型別的如以下表格所列。\n", "\n", "| 物件類型 | Mutability | 內建物件型別 |\n", "|-----------|--------------|-----------------------------------------|\n", "| 數值 | *immutable* | **`int`, `bool`, `float`, `complex`** |\n", "| 序列 | *mutable* | **`list`, `bytearray`** |\n", "| 序列 | *immutable* | **`str`, `tuple`, `bytes`** |\n", "| 對應集 | *mutable* | **`dict`** |\n", "| 集合 | *mutable* | **`set`** |\n", "| 檔案/串流 | n/a | **`file`** |\n", "| NoneType | n/a | **`None`** |\n", "\n", "- 內建函式 `type()` 可以用來檢驗物件的型態。\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "### § 數值 Numbers\n", "| 型別 | 範例 |\n", "|-------------|-------------------------------------------------------|\n", "| **int** | `1234`, `−24` ,`0`, `0x9ff`（十六進位）, `0b1111`（二進位）|\n", "| **bool** | `True`（1）, `False` （0） |\n", "| **float** | `1.23`, `3.14e-10`, `4E210`, `4.0e+210`, `1.`, `.1` |\n", "| **complex** | `3+4j`, `3.0+4.0j`, `3J` |\n", "\n", "- 內建函式 `int()`、`float()`、`complex()` 可以用來將字串轉換成數值類型。\n", "- 內建函式 `ord()` 可以用來將字元轉換成對應的字碼值，是 `chr()` 的逆向操作。\n", "- 內建函式 `print()` 可以用來將數值內容輸出至畫面。\n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(int, float, float)" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 小小的小數點很容易被忽略，有沒有一個小點是不一樣的\n", "type(17), type(17.), type(.17)" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(True, True)" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 布林值是整數 int 的子類別，但不是用來作數值運算的，主要用於流程控制時的條件判斷\n", "type(False) is bool, type(True) == bool" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "number1 = 65 , number2 = 0.001\n" ] } ], "source": [ "# 從字串轉換成數值\n", "print('number1 =', int('0x41', base=16), ', number2 =', float(' 1e-003 \\n'))" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(65, 'A')" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 字元 'A' 的 ASCII 碼\n", "ord('A'), chr(0x41)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "### § `str` 字串\n", "\n", "[`str`](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)字串是以字元為元素的序列資料結構，字串的語法使用單引號或雙引號包起來，一樣的引號要成對使用。\n", "\n", "元素內容是按照儲存順序的 index 存取，語法為 **`[ index ]`**。 如果按照由前往後的順序，**第一個元素 index 是0**，依次往後遞增； 如果反過來由後往前存取，**最後一個元素 index 可以用-1**，依次向前遞減。\n", "\n", "| 字串範例 | 說明 |\n", "|------------------------------|-----------------------------------------------|\n", "| `''` | 空字串 |\n", "| `\"Python's\"`, `'Python\"s'` | 字串用單引號或雙引號包起來 |\n", "| `'Python\\'s\\n'` | 特殊字元前面要加反斜線 `\\` |\n", "| `r'c:\\Users\\name'` | 引號前置碼`r`保留字串呈現的原貌（raw string） |\n", "| `\"This\" \"is\" \"concatenated\"` | 相鄰的字串會自動被串接起來 |\n", "\n", "- 內建函式 `str()` 回傳物件的字串版本。\n", "- 內建函式 `hex()`、`bin()` 分別可以用來將數值轉換成十六進位及二進位的數字字串。\n", "- 內建函式 `chr()` 可以用來將字碼轉換成對應的字元，是 `ord()` 的逆向操作。\n", "- 內建函式 `len()` 可以用來回傳字串的長度。\n", "- 內建函式 `print()` 可以用來將字串內容輸出至畫面。\n" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "拍神\t好\n", "好玩\n" ] } ], "source": [ "# 包含特殊字元的字串\n", "print('拍神\\t' '好\\n' '好玩')" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "拍神好好玩\n" ] }, { "data": { "text/plain": [ "(None, 5)" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 相鄰的字串視為串接起來的一個字串\n", "print('拍神' '好' '好玩'), len('拍神' '好' '好玩')" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(False, True, True)" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 當用於邏輯條件判斷時，空字串視為 False，其他則視為 True\n", "bool(''), bool('any string'), bool('False')" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(65, '0x41', '0b1000001')" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 輸出不同進位制的數字字串\n", "ord('A'), hex(ord('A')), bin(ord('A'))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "### § `list` 序列容器\n", "\n", "[`list`](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range) 是存放序列性資料的結構。語法使用逗號 `,` 分隔資料元素，用中括號（square brackets）`[` `]` 成對包住所有元素。`list`可以是巢狀多維度的，同一個`list`中也可以存放異質類型資料，不過一般使用情境還是以同類型的資料較適合。\n", "\n", "元素內容是按照儲存順序的 index 存取，語法為 **`[ index ]`**。 如果按照由前往後的順序，**第一個元素 index 是0**，依次往後遞增； 如果反過來由後往前存取，**最後一個元素 index 可以用-1**，依次向前遞減。 \n", "\n", "| List 範例 | 說明 |\n", "|------------------------------------|-----------------------------------------------|\n", "| `[]` | 空的 list |\n", "| `[5, 6, 7, 8]` | 四個數字元素的 list |\n", "| `['code', [42, 3.1415], 1.23, {}]` | 巢狀、異質的 list |\n", "\n", "- 內建函式 `list()` 可以用來從現有物件的資料實體中生成一個新的list。\n", "- 內建函式 `len()` 可以用來回傳容器裡的元素個數。\n", "- 內建函式 `min()` 可以用來回傳容器中最小的元素。\n", "- 內建函式 `max()` 可以用來回傳容器中最大的元素。\n" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 利用內建函式 range(stop) 產生整數數列的 List\n", "# range 預設從 0 開始直到指定的整數“的前一個整數”\n", "list(range(10))" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9]" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 也可以分別指定開始、結束、及區間間隔 range(start, stop, step)\n", "L = list(range(9, -10, -1))\n", "L" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(9, -9)" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 用 index 存取 List 元素\n", "L[0], L[len(L) - 1]" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(-9, 9)" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 搭配使用內建函式\n", "min(L), max(L)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(False, True)" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 空的 List 在邏輯上是 False\n", "bool([]), list(range(0)) == []" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "### § `tuple` 序列容器\n", "\n", "[`tuple`](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range) 也是存放序列性資料的結構。語法使用逗號 `,` 分隔資料元素，用小括號（parentheses）`(` `)` 成對包住所有元素，但括號可以省略。 `tuple`可以是巢狀多維度的，同一個`tuple`中也可以存放異質類型資料，通常使用在函式參數的傳遞與回傳。\n", "\n", "元素內容是按照儲存順序的 index 存取，語法為 **`[ index ]`**。 如果按照由前往後的順序，**第一個元素 index 是0**，依次往後遞增； 如果反過來由後往前存取，**最後一個元素 index 可以用-1**，依次向前遞減。\n", "\n", "| tuple 範例 | 說明 |\n", "|------------------------------------|-----------------------------------------------|\n", "| `()` | 空的 tuple |\n", "| `('code',)` | 單一元素的 tuple |\n", "| `(5, 6, 7, 8)` | 四個數字元素的 tuple |\n", "| `('code', (42, 3.1415), 1.23, {})` | 巢狀、異質的 tuple |\n", "| `'code', 42, 3.1415, 1.23` | 括號可以省略 |\n", "\n", "- 內建函式 `tuple()` 可以用來從現有物件的資料實體中生成一個新的tuple。\n", "- 內建函式 `len()` 可以用來回傳容器裡的元素個數。\n", "- 內建函式 `min()` 可以用來回傳容器中最小的元素。\n", "- 內建函式 `max()` 可以用來回傳容器中最大的元素。" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 單一元素 tuple 的表示比較特殊，逗號不能省略\n", "tuple([99]) == (99,)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(1, 3, 5, 7, 9)" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 內建函式 range() 一樣可以用來幫忙產生整數數列的 tuple\n", "t = tuple(range(1, 10, 2))\n", "t" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(1, 9, 5, 1, 9)" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 用 index 存取 tuple 元素，以及內建函式的使用\n", "t[0], t[4], len(t), min(t), max(t)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "### § `dict` 字典容器\n", "\n", "[`dict`](https://docs.python.org/3/library/stdtypes.html#mapping-types-dict) 是非序列式的資料結構，元素內容的儲存是成對的 key 和對應的 value。語法使用冒號組成 key 和 value 對應組 `key:value`，以逗號 `,` 分隔對應組元素，用大括號（curly braces）`{` `}` 成對包住所有元素。 同一個 `dict` 中的 `value` 可以存放異質類型資料。`dict` 也可以是巢狀的，也就是 `value` 中含有另外一個 `dict` 類型的資料。\n", "\n", "元素內容必須用 `key` 來存取，語法為 **`[ key ]`**。\n", "\n", "| dict 範例 | 說明 |\n", "|------------------------------------|-----------------------------------------------|\n", "| `{}` | 空的 dict |\n", "| `{'alpha': 2, 'beta': 3}` | 兩個元素的 dict |\n", "| `{ 'parameter': { 42: 1.5, 'angle': 30 }, 'date': ['2018-06-08'] }` | 巢狀、異質的 dict |\n", "| `dict([['a', 1], ['b', 2], ['c', 3]])` | 由list中建構一個新的dict物件 |\n", "\n", "- 內建函式 `dict()` 可以用來從現有物件的資料實體中生成一個新的字典容器。\n", "- 內建函式 `len()` 可以用來回傳容器裡key-value對的個數。" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "('鮑伯', True)" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Dict 非常適合用在非同質性資料組成的記錄集\n", "d1 = {'name':'鮑伯', 'age':45, 'job':('經理', '研發')}\n", "d1['name'], d1['age'] < 50" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "one two three\n" ] } ], "source": [ "# 由 List 中對應元素產生\n", "d2 = dict([[1, 'one'], [2, 'two'], [3, 'three']])\n", "print(d2[1], d2[2], d2[3])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "### § `set` 集合容器\n", "\n", "[`set`](https://docs.python.org/3/library/stdtypes.html#set-types-set-frozenset) 是非序列式、元素內容不重複的資料結構，提供了數學集合運算方法的支援，如聯集（union）、交集（intersection）、差集（difference）、對稱差（symmetric difference）。 可以使用大括號`{` `}`或`set()`函式建立集合物件，集合成員以逗號`,`分隔。 雖然不是序列式的容器，但是 `set` 物件也支援逐項元素存取的 *iteration* 操作。\n", "\n", "| set 範例 | 說明 |\n", "|----------------------------------------|----------------------------------------|\n", "| `set()` | 空的集合，注意不能用 `{}` |\n", "| `{'apple', 'orange'}` | 兩個元素的集合 |\n", "| `{'orange', 'banana', 5, ('pear',20)}` | 異質元素的集合 |\n", "| `set(['a', 'b', 'c'])` | 由 list 中建構一個新的集合物件 |\n", "\n", "- 內建函式 `set()` 可以用來從現有物件的資料實體中生成一個新的集合。\n", "- 內建函式 `len()` 可以用來回傳容器裡元素成員的個數。" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "集合1: {'a', 'r', 'd', 'b', 'c'}\n", "集合2: {'a', 'l', 'm', 'z', 'c'}\n" ] } ], "source": [ "s1 = set('abracadabra')\n", "s2 = set('alacazam')\n", "\n", "print('集合1: ', s1)\n", "print('集合2: ', s2)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'a', 'b', 'c', 'd', 'l', 'm', 'r', 'z'}" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 聯集：所有集合1與集合2有出現的元素\n", "s1 | s2" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'a', 'c'}" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 交集：同時有出現在兩個集合的元素\n", "s1 & s2" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'b', 'd', 'r'}" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 差集：只在集合1，不在集合2的元素\n", "s1 - s2" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'b', 'd', 'l', 'm', 'r', 'z'}" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 對稱差：沒有同時出現在兩個集合的元素\n", "s1 ^ s2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## 2.2 操作運算子 Operators\n", "\n", "\n", "### § 數值與算術運算 Numeric and Arithmetic Operations\n", "| 算數的操作 | 說明 |\n", "|--------------------|--------------|\n", "| **X + Y, X - Y** | 加法，減法 |\n", "| **X \\* Y, X / Y** | 乘法，除法 |\n", "| **X // Y, X % Y** | 取商，取餘數 |\n", "| **X\\*\\*Y** | 次方 |\n", "| **X | Y, X & Y** | 位元 OR，AND |\n", "| **X ^ Y, ~X** | 位元 XOR，NOT |\n", "| **X << Y, X >> Y** | 位元左位移，右位移 |\n" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "302" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 數值運算範例 - 計算一個很大的數字有幾位數\n", "len(str(2 ** 1000))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "這些運算子不是只有數值可以用。 這是物件導向的一個重要的特質叫***多型*** ： 相同概念的方法，行為會因為作用在不同類型的物件而有所改變。" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'拍神好棒棒拍神好棒棒拍神好棒棒'" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 字串支援 '+' 和 '*' 的運算\n", "p = '拍神' + '好棒棒'\n", "p * 3" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['拍', '神', '好', '棒', '棒', 1, 2, 3, '拍', '神', '好', '棒', '棒', 1, 2, 3]" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# List 與同樣是序列容器的字串一樣，支援 '+' 和 '*' 的運算\n", "L = list(p) + [1, 2, 3]\n", "L * 2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### § 布林運算 Boolean Operations\n", "\n", "| 布林的運算 | 程式解譯邏輯 | 說明 |\n", "|-------------|-------------------------------------|--------------------------------------|\n", "| **X or Y** | 假如X為False則Y，否則X。 | 其中一個為True就是True，否則是False |\n", "| **X and Y** | 假如X為False則X，否則Y。 | 兩個都為True才是True，否則是False |\n", "| **not X** | 假如X為False則True，否則False。 | 反轉 |\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### § 比較運算 Comparisons Operations\n", "\n", "| 比較的運算 | 說明 |\n", "|----------------|--------------|\n", "| **X < Y** | 小於 |\n", "| **X <= Y** | 小於或等於 |\n", "| **X > Y** | 大於 |\n", "| **X >= Y** | 大於或等於 |\n", "| **X == Y** | 等於 |\n", "| **X != Y** | 不等於 |\n", "| **X is Y** | 是否相同物件 |\n", "| **X is not Y** | 是否不同物件 |\n", "\n", "- 對於容器物件的直接比較， ***“大於”*** 和 ***“小於”*** 的概念可能時常沒什麼太大意義， ***“等於”*** 或 ***“不等於”*** 則時常用到。\n", "- 物件在電腦裡都有一個對應的記憶體存放位址，可以用 `id()` 取得。 當 `is` 比較兩個物件是否相同時，實際比較的就是兩個物件是否有相同 `id()`。\n" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(int, float, True)" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 不同的數值型態可以互相比較（實際上是，int 2會先被自動轉型提升為 float，再進行比較）\n", "type(2), type(2.0), 2 == 2.0" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(True, False, False, True)" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 兩個字串用比較運算子時，方法是從第一個字元開始，比較出現第一個不同字元的 ASCII 碼（ord()）的大小\n", "s1 = 'This is a book'; s2 = 'That is a book'\n", "'i' > 'a', s1 < s2, s1 == s2, s1 > s2" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(True, False, False)" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 兩個 List 或兩個 Tuple 用比較運算子時，方法是從第一個元素開始，比較出現第一個不同元素的大小\n", "L1 = [1, 2, 3, 4, 5]; L2 = [1, 2, 4]\n", "L1 < L2, L1 == L2, L1 > L2" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 不同型別不能作比較，除了（型別1 == 型別2）永遠回傳 False 以外，其他的比較都會出現 TypeError 的錯誤\n", "17 == '17'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## 2.3 變數與物件 Variable and Object\n", "\n", "### § 指派述句 Assignment Statements\n", "Python是**動態型別（dynamic type）**的程式語言。為資料或物件指定變數名字時，程式碼中不需要明確宣告變數的型別。例如：當指定 `a = 3` 時，Python 會根據你的要求做這些步驟：\n", "1. 判斷 3 屬於 int 型別。\n", "2. 建立一個 3 的 int 物件。\n", "3. 建立一個名字叫做 a 的變數（如果原本 a 不存在）。\n", "4. 把變數 a 參考到物件 3 的關係連結起來。\n", "\n", "是**物件擁有型別**，不是變數。變數只是個指向參考物件的名字而已。" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "\n", "\n" ] } ], "source": [ "a = 3\n", "print(type(a))\n", "\n", "# 改變 a 參考的物件\n", "a = 'a string'\n", "print(type(a))\n", "\n", "# 再一次改變 a 參考的物件\n", "a = [5, 6, 7]\n", "print(type(a))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### § 強型別 Strongly Typed\n", "\n", "Python是強型別（strongly typed）的程式語言。在操作運算兩個不同型別的物件時，不相容的型別不會私下自動轉換（implicit type conversions）。程式設計員必須明確知道要的操作運算是甚麼，自己明確指定型別轉換。\n", "\n", "如果知道字串內容是數字的格式，可以用 int(), bool(), float(), complex() 來轉型。 而幾乎所有的物件都可以使用 str() 來呈現字串版的物件內容。" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "unsupported operand type(s) for +: 'int' and 'str'", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[0mb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'8'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;31m# 數值與字串相加結果未定義，如果沒有明確轉型，會出現 TypeError 的錯誤\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0ma\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mb\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'" ] } ], "source": [ "a = 3\n", "b = '8'\n", "# 數值與字串相加結果未定義，如果沒有明確轉型，會出現 TypeError 的錯誤\n", "a + b" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'[0, 1, 2, 3, 4, 5, 6]'" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "L = list(range(7))\n", "# 把 List 物件內容用字串表示\n", "str(L)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### § 物件參考 Object Reference\n", "\n", "兩個變數可以共享物件的參考。當變數 a 和 b 參考至同一個物件：\n", "- 對於可以就地變更元素內容的容器而言，修改 b 的元素內容，因為是同一份物件，a 的元素內容跟著變。\n", "- 若指定一個新的物件給其中一個變數，就算內容一模一樣，兩變數結果會是參考至不同物件。\n" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\"b == a\" True\n", "\"b is a\" True\n" ] } ], "source": [ "a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "b = a\n", "\n", "# \"==\"比較內容，\"is\"判斷是否為同一個物件參考，應該都會是 True\n", "print('\"b == a\"', b == a)\n", "print('\"b is a\"', b is a)" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\"b == a\" True\n", "\"b is a\" True\n" ] } ], "source": [ "# a 和 b 參考至同一物件\n", "a = b = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "\n", "# 修改一個的元素內容，另一個會跟著變\n", "b[-1] = 11\n", "print('\"b == a\"', b == a)\n", "print('\"b is a\"', b is a)" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\"b == a\" True\n", "\"b is a\" False\n" ] } ], "source": [ "# a 和 b 參考至同一物件\n", "a = b = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "\n", "# 指定相同內容的新物件給 b，兩變數的參考物件變成不同\n", "b = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "print('\"b == a\"', b == a)\n", "print('\"b is a\"', b is a)" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\"b == a\" True\n", "\"b is a\" False\n" ] } ], "source": [ "# a 和 b 參考至同一物件\n", "a = b = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "\n", "# 同樣是指定了新物件 － list經過索引返回的片段是新的物件\n", "b = a[:]\n", "print('\"b == a\"', b == a)\n", "print('\"b is a\"', b is a)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "## 2.4 序列容器的操作 Sequence Operations\n", "\n", "### § 索引規則 Indexing Rules\n", "- 在序列容器變數後，使用中括號內置索引序號，如：`S[3]`。\n", "- 序列第一個元素的索引序號為 `0`，往後面依次遞增。如：`S[0]`, `S[1]`, ..., `S[len(S) - 1]`。\n", "- 序列最後一個元素的索引序號為 `-1`，往前面依次遞減。如：`S[-1]`, `S[-2]`, ..., `S[-len(S)]`。\n", "- 可以使用的索引序號不能超過物件的元素個數減1。如：`S[len(S)]` Python會出現錯誤訊息。" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# List 是最常用的序列容器\n", "L = list(range(1, 10))\n", "(L[0] == L[-len(L)]) and (L[-1] == L[len(L) - 1])" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 字串是字元的序列\n", "s = str(L)\n", "(s[1] == '1') and (s[-2] == '9') and (s[1] < s[-2])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### § 片段規則 Slicing Rules\n", "由序列容器中取出片段成為一個新的序列容器物件，可以取得的片段範圍僅限於合法的索引範圍。若指定的片段超過範圍，所產生的新序列容器只會包含合法範圍內的片段，Python不會發出錯誤訊息。片段範圍的指定一樣使用中括號，語法如下：\n", "\n", "

\n", " [ 起始序號 : 結束序號 : 遞增（減）量 ]\n", "

\n", "\n", "- 注意索引結果的元素，不包含結束序號的那個元素；也就是說 `[start : end]` 取的是 $[start, end)$ 的區間。\n", "\n", "| Slicing 的操作 | 說明 |\n", "|----------------|----------------------------------------------|\n", "| `S[1:3]` | 取元素範圍序號 1 到 2 |\n", "| `S[1:]` | 取元素範圍序號 1 到最後一個 |\n", "| `S[:-1]` | 取元素範圍第一個到最後一個的前一個 |\n", "| `S[:]` | 取所有範圍的元素 |\n", "| `S[2::3]` | 元素範圍序號 2 到最後一個，每遞增 3 個序號取 |\n", "| `S[::2]` | 所有元素的範圍內，從頭到尾每隔一個序號取 |\n", "| `S[::-1]` | 反向取所有範圍的元素 |\n", "| `S[-2:0:-1]` | 所有範圍的元素去頭尾，反向取 |" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 2, 1]" ] }, "execution_count": 40, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# List slicing 練習\n", "L = list(range(1, 10))\n", "L[:-1] + L[::-1]" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[7, 8, 9, 8, 7, 6, 5, 4, 3, 2]" ] }, "execution_count": 41, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# List slicing 練習\n", "L[6:] + L[-2:0:-1]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### § 成員操作 Membership Operations\n", "| 成員的操作 | 說明 |\n", "|------------------------|------------------------------------------------------------------|\n", "| `x in S` | S 的成員裡有 x（只要值相同就算），結果為 `True` 或 `False` |\n", "| `x not in S` | S 的成員裡沒有 x ，結果為 `True` 或 `False` |\n", "| `for x in S:` | （迴圈）列舉 S 裡的成員到 x |\n" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 判斷是否存在成員\n", "L = list(range(10))\n", "(9 in L) and (10 not in L)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### § 卸載操作 Unpacking Operations\n", "當序列容器或可迭代（iterable）物件在等號（`=`, assignment）右邊，等號左邊如果有對應元素個數的變數，容器的元素內容會自動分派卸載。\n", "\n", "| 自動卸載 | 結果 |\n", "|----------------------------|------------------------|\n", "| `a, b, c = [1, 2, 3]` | a = 1, b = 2, c = 3 |\n", "| `a, b, c = (1, 2, 3)` | a = 1, b = 2, c = 3 |\n", "| `a, b, c = 1, 2, 3` | a = 1, b = 2, c = 3 |\n", "| `a, b, c = range(3)` | a = 0, b = 1, c = 2 |\n", "\n", "容器卸載是將每個元素拆到容器外，卸載操作通常用在卸載不同類型容器的內容到新容器，或容器內容卸載為叫用函式的參數。 一般可以列舉的、序列型態的容器、字典的 key 都用 `*` 操作，字典容器的 value 用 `**` 卸載。\n", "\n", "| 卸載操作 | 輸出 |\n", "|---------------------------------------------------------|------------------------|\n", "| `print(*range(4))` | 0 1 2 3 |\n", "| `*range(4),` | (0, 1, 2, 3) |\n", "| `[*range(4), 4]` | [0, 1, 2, 3, 4] |\n", "| `'unpack keys: {}, {}'.format(*{'a':1, 'c':3})` | 'unpack keys: a, c' |\n", "| `'unpack values: {a}, {c}'.format(**{'a':1, 'c':3})` | 'unpack values: 1, 3' |" ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1 2 3 4 5\n" ] } ], "source": [ "# 用在函式的呼叫，卸載到函式的參數\n", "print(*[1], *[2], 3, *[4, 5])" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[0, 1, 2, 3, 4, 5, 6, 7]" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 用在將非同類型容器的內容卸載到新容器\n", "[*range(4), 4, *(5, 6, 7)]" ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'Coordinate System: latitude, longitude'" ] }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 卸載 dict 的 key\n", "'Coordinate System: {}, {}'.format(*{'latitude': '37.24N', 'longitude': '-115.81W'})" ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'Coordinates: 37.24N, -115.81W'" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 卸載 dict 的 value\n", "'Coordinates: {latitude}, {longitude}'.format(**{'latitude': '37.24N', 'longitude': '-115.81W'})" ] } ], "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.8.8" } }, "nbformat": 4, "nbformat_minor": 2 }