用 Python 快寫程式

下載與安裝 CPython

Python 有多家直譯器，其中官方開發的是 CPython，請至 http://www.python.org 下載安裝程式。

安裝時，勾選「Add Python 3.x to PATH」就不用自己設定系統變數了。

Hello, world!

用記事本寫入如下程式，並儲存檔案為 main.py：

notepad('main.py','print(\'Hello, world!\')')

進入命令提示字元，切換到 main.py 位置，輸入 python main.py，Python 安裝正常的話會顯示 Hello, world!：

cmd('C:\\Users\\User\\Desktop>python main.py','Hello, world!','','C:\\Users\\User\\Desktop>_')

Python shell

輸入 python 後面不接原始碼檔案，會進入 Python shell，一個能夠用 Python 語言操作系統的環境。

你可以一邊使用 help('指令') 查詢指令，一邊撰寫 Python 程式。或使用 dir('物件') 列出功能來操作。

通常會使用到 os 模組，與作業系統聯繫，例如取得作業系統的環境變數：

>>> import os
>>> print(os.environ['PATH'])

或者調用作業系統的指令：

>>> os.system['cls']

想結束 Python shell 請輸入 exit() 或 Ctrl+C。

教學資源

Python 官方的入門教程《The Python Tutorial》已有中文翻譯，自然是學習的首選！還可以下載到自己電腦隨時閱讀：http://docs.python.org/zh-tw/3/download.html，真覺得我之前寫的這些教學範例是多餘的 XD

其次是「菜鸟教程」用範例一步驟一步驟教學的《Python 3 教程》，它像 1998 年代電腦人（PCuSER）推出的 Tips 系列叢書，去掉大量說明文字，用圖解把重點 step by step 教給你。

學會 Python 3 以後，再看《Python 慣用語》學習成熟的 Python 程式寫作技巧，然後懂得查《The Python Standard Library》發揮 Python 內建程式庫的功能，就搞定一切了。

愛上 Python 後，你會很享受《Effective Python 心得筆記》的內容。

基礎範例集

資料與輸出入
運算
陣列
敘述、區塊、段落
流程
迭代
函式
類別
模組
Docstring
異常（Exception）
推斷（Assertion）
開頭宣告與設定
字串格式化
賦值運算式（Assignment expressions）

應用範例集

bytes
str
tuple
list
set
dict
處理可迭代資料
處理物件與變數
處理算式
格式化數字
讀寫檔案
breakpoint

進階範例集

tkinter 圖形化介面
os, shutil 作業系統與檔案系統
sys 直譯器的系統環境與功能設置
ctypes 調用 DLL 程式功能
time 日期與時間的表示法
datetime 計算日期與時間
calendar 月曆
random 亂數產生器
re 匹配資料
sqlite3 資料庫系統
csv 字符分隔表
pickle 序列化（二進制檔案）
json 序列化（純文字格式）
xml.etree.ElementTree 剖析 XML 檔案
tarfile, gzip, bz2, lzma 檔案封裝與壓縮
zipfile 最通用壓縮格式
base64 字元轉碼
logging 日誌檔
pdb 除錯器
socket 網路連線
http.server 自帶網站伺服器能力
cgitb 獲取執行異常訊息
cgi 接收 GET 或 POST 資料
urllib.rulparse, urllib.urlunparse 網址的剖析
http.cookies 客端資料儲存
codecs 解決 Windows 的 UTF-8 亂碼問題
smtplib, smtpd 寄發電子郵件
webbrowser 啟動網頁瀏覽器
urllib.request 程式端網頁存取
xmlrpc.server, xmlrpc.client 遠端呼叫

延伸主題選

Pythonic：這樣寫才 Python！
Python 編程風格指南
Pyton 之禪
Effective Python 中文版目錄
Web Service … Python Wiki
Pygame

附錄

Python 3 指令一覽表
Python 3 內建函式一覽表
底線命名原則

輸入、輸出、變數

資料

print(123) # 整數 print(0x7b) # 十六進位值 print(0o173) # 八進位值 print(0b1111011) # 二進位值 print(b'\x7b') # 位元組 print('hello') # 字串 print(r'\n') # Raw string（引號內的資料都是字串，不會轉義字元。）

123
123
123
123
b'{'
hello
\n

資料本身就是物件，所以可以直接對資料操作物件的功能：

print('ABC'.lower())

abc

型態

# 取得資料的型態 a = 123 print(type(a))

<class 'int'>

轉換

print(int('123')) # 轉為整數 print(float(123)) # 轉為小數 print(bin(123)) # 轉為二進位的數字（字串） print(oct(123)) # 轉為八進位的數字（字串） print(hex(123)) # 轉為十六進位的數字（字串） print(str(123)) # 轉為字串 print(chr(123)) # 轉為 Unicode 字元 print(ord('A')) # 轉為 Unicode 編碼 print(ascii('哈囉')) # 轉為 ASCII 表示法（用最基本的字元表示所有資料） print(bool(0)) # 轉為布林值（可接受串列）

123
123.0
0b1111011
0o173
0x7b
123
{
65
'\u54c8\u56c9'
False

用 bin() oct() hex() 轉出來的是字串，因此無法直接拿來做數學四則運算，必須先將字串轉為整數：

a = int(bin(123), 2) + int(bin(123), 2) print(bin(a))

0b11110110

既然是字串，就可以用 [2:] 擷取 0b 以後的文字，獲得 11110110。

很少需要將整數轉為其他進位的數來計算，平常都是直接拿 0b 0o 0x 開頭的資料計算就好，會將十進位整數轉為其他進位的數，通常都是為了看轉換結果而已，而不是拿來計算，所以使用字串提高輸出的效率很合理。

True 與 False

底下資料為 False：

'' 0 [] () {} set() None

除此之外都是 True。

數學運算

a = 10 b = 3 print(a + b) # 加 print(a - b) # 減 print(a * b) # 乘 print(a / b) # 除 print(a % b) # 取餘數 print(a // b) # 取商數 print(a ** b) # 次方

13
7
30
3.3333333333333335
1
3
1000

Python 沒有 ++ 和 -- 之類的功能，但是有 += 和 -= 之類的可用。

邏輯運算

a = True b = False print(a and b) print(a or b) print(not a)

False
True
False

關係運算

a = 8 b = 2 print(a < b) print(a > b) print(a == b) print(a != b)

False
True
False
True

位元運算

a = 0b1001 b = 0b1111 print(bin(a & b)) print(bin(a | b)) print(bin(a ^ b)) print(bin(a >> 1)) print(bin(a << 1)) print(bin(~a))

0b1001
0b1111
0b110
0b10010
0b100
-0b1010

函數計算

print(abs(-123)) # 取絕對值 print(complex(4, 5)) # 複數 print(divmod(11, 3)) # 以 Tuple 傳回商數和餘數 print(pow(2, 3)) # 2 的 3 次方 print(round(9.6)) # 四捨五入

123
(4+5j)
(3, 2)
8
10

Example 1

a = ['AAA', 'BBB', 'CCC'] print(a[0]) print(a[1]) print(a[2])

AAA
BBB
CCC

Example 2

a = ['AAA', 'BBB', 'CCC'] b = ['ABC'] * 3 c = a + b print(a) print(b) print(c)

['AAA', 'BBB', 'CCC']
['ABC', 'ABC', 'ABC']
['AAA', 'BBB', 'CCC', 'ABC', 'ABC', 'ABC']

Example 3

a = [1, 2, 3, 4, 5, 6, 7, 8, 9] print(a[1]) # 取得第二筆資料。 print(a[2:4]) # 從第三筆資料開始擷取，第五筆資料停止。 print(a[2:]) # 擷取第三筆和以後的資料。 print(a[:-2]) # 從頭開始擷取資料，倒數第二筆資料停止。 print(a[::2]) # 每隔二筆取出資料。 print(a[::-1]) # 反轉資料。

2
[3, 4]
[3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7]
[1, 3, 5, 7, 9]
[9, 8, 7, 6, 5, 4, 3, 2, 1]

Example 4

# 判斷串列中是否有某筆資料 print('xyz' in ['AAA', 'BBB', 'CCC'])

False

敘述與區塊

一段完整的程式叫做「敘述（statment）」，連續個敘述叫做「區塊（block）」。

在 Python 每一行就表示一個敘述，因此你不能跳行寫程式，每一句完整程式就是要在一行寫完。

Python 使用縮排表示區塊，同樣縮排的連續個敘述，視為同一區塊。至於要怎樣縮排沒有硬性規定，吃飽沒事用「一個 Tab 字元 + 八個空白字元」這種方式來縮排也可以，只要每行敘述都以同樣方式縮排即可。官方建議使用四個空白字元縮排。

如果執行程式時看到 IndentationError 訊息，就表示不符合縮排規定。

其它程式語言經常使用 ; 表示一段敘述，所以在下 ; 符號之前，程式碼可以不斷換行寫下去。然後使用 {} 或 begin end 將區塊包起來，在範圍之內的程式就算亂排也是同一區塊。相比之下 Python 的規定不甚自由，但犧牲自由換來乾淨整潔、讀起來甚為舒適的程式碼，還是很值得的。其它程式語言一定要用 ; 或 } 作結尾，再怎麼縮排也無法像 Python 乾淨、美觀，可是羨慕得流口水呢～

但靠縮排表示區塊也有缺點，像 lambda 因此只能寫一個敘述，沒辦法像其他語言直接用匿名函數寫一整塊程式來執行，詳情請看匿名函數的範例。

段落

凡事總有例外的時候，如果非得打破一行代表一段敘述、同樣縮排代表一個區塊的規定怎麼辦？

# 寫成一行 a = 'ABC'; a += a; print(a) # 拆成多行 a = 'AAA' + \ 'BBB' + \ 'CCC' # 多行字串 a = """AAA BBB CCC""" # 空佔一行 pass

條件

迴圈

for.. in..

Python 的 for 並不是 C 語言的 for 迴圈，而是 C Shell Script 的 foreach 迭代，只能搭配 iterator 使用。

不過，寫過傳統結構化程式設計的人，看到 for 就想拿來跑計數器迴圈，所以最常用到的 iterator 是 range()，產生連續數值讓 foreach 迭代。但別忘了 list 或 generator 之類的可迭代資料，也是 foreach 的迭代對象，可別又拿 range() 當索引值去迭代它們 XD

for.. else..

for 可以使用 else，但容易誤解的是，它並不是找不到的話才執行，而是迭代完再執行：

for n in range(1, 4): print(n) else: print('end')

1
2
3
end

你可以在 for 裡面用 break 來跳過 else 的程式。

List comprehension expression

for.. in.. 有專屬語句，句型是：

已傳元素運算式 for 元素 in 串列 未傳元素運算式

先看後面的「未傳元素運算式」，在這裡可以對正在迭代而還沒傳回的元素進行運算，例如用 if n%2==0 篩選出能夠整除的偶數，或者再用 for.. in.. 變成多維陣列的迭代句。前面的「已傳元素運算式」可以對 for 每次迭代出來的項目進行運算，例如 n*3 將結果通通乘以三倍：

a = [1, 2, 3, 4, 5, 6, 7, 8, 9] print([n*3 for n in a if n%2==0])

[6, 12, 18, 24]

使用 list comprehension expression 所獲得的資料是 generator 物件，這是一種可迭代資料（iterable）的物件，所以上面的範例，前後用 [] 包住，讓 print() 以 list 資料輸出，可視場合改用 {} 或 () 或不包，這不是語法結構的一部分。

重點是要操作 generator 物件來使用迭代句，例如在前面加上 * 符號，直接將資料拆解出來：

a = (n*n for n in [1, 2, 3]) print(a) # 這樣只會輸出 generator 物件訊息 print(*a) # 前面加個星號進行 iterable 的拆解

<generator object <genexpr> at 0x0000024E48B9BFC0>
1 4 9

具名函式

# 函式 def f(x): return x print(f(123))

123

預設參數

# 關鍵字參數 def f(x, y='BBB', z=''): print(x, y, z) f('AAA') # 可做為預設參數 f('AAA', z='CCC') # 指定關鍵字下參數，適用於不照參數順序走。 f(111, 222, 333) # 照參數順序走的話，不妨省略關鍵字。

AAA BBB
AAA BBB CCC
111 222 333

不定參數

# 可接受 tuple 形式的參數 def f1(*x): print(x) # 可接受 dict 形式的參數 def f2(**x): print(x) f1(1, 3, 5) f2(a=1, b=3, c=5)

(1, 3, 5)
{'a': 1, 'b': 3, 'c': 5}

順位參數

參數可以使用 / 符號，在這符號之前的參數，只能像傳統程式設計的函式一樣，照位置順序傳入使用，無法再使用關鍵字引數：

def f(x, y, z, /): print(x, y, z) f(111, 222, 333) f(333, 222, 111) f(x=111, y=222, z=333)

111 222 333
333 222 111
TypeError: f() got some positional-only arguments passed as keyword arguments: 'a, b, c'

/ 只對前面的參數產生限制，後面的參數則可正常使用，因此可設計出混搭照位置順序使用的參數與用關鍵字選擇性使用的參數。

函式注釋

函式的參數，可以用 : 符號註釋：

def f(x: int): return x

匿名函數

用 lambda 指令即時跑一個匿名函數：

(lambda x: print(x))('Hello')

Hello

礙於一行一敘述、又無法縮排寫多行程式的限制，lambda 只能寫短短一行程式。唯一解決方式是另外寫個具名函式來用，有夠鳥的 (σﾟ∀ﾟ)σﾟ∀ﾟ)σﾟ∀ﾟ)σ

def f(x): if x <= 100: a = 123 - x else: a = 123 + x print(a) (lambda x: f(x))(456)

579

那些靠 } 或 end 表示區塊結束的語言，只要沒結束區塊前，要塞多少行程式給 lambda 都無所謂，反而沒這個問題 o(*≧▽≦)ツ┏━┓

產生器

def f(): yield 'AAA' yield 'BBB' yield 'CCC' a = f() for n in a: print(n)

AAA
BBB
CCC

yield 跟 return 一樣，用來傳回資料，但不會結束函式，程式會繼續往下執行，而且可以再用 yield 傳出資料，讓函式可以傳回多筆資料。善用這項特性，可以讓程式碼有更多樣的設計。

yield 能傳回多筆資料，是因為使用了像 list 一樣可以連續保存資料的 generator。所以用 yield 傳回資料的話，函式的型態就是 generator，不像 return 傳回 'ABC' 時函式是字串型態，傳回 123 時是整數型態；yield 不管傳回 'ABC' 或 123 都是 generator 物件型態。也因此，使用 yield 的函式，大家會稱為產生器（Generator）。

由於 generator 是種 iterable 資料，因此除了可以迭代，也可使用 * 符號拆解資料：

def f(): yield 'AAA' yield 'BBB' yield 'CCC' a = f() print(*a)

AAA BBB CCC

初涉入 Python 的人，最感到棘手的，正好就是產生器的資料不知如何使用！幾乎函式丟出的資料都是產生器，輸出時總顯示說這是物件，卻又不知道如何從中取得資料，尤其是沒辦法用陣列的索引值方式去取出資料，最讓其它語言跳過來的人感到困擾。所以底下特別示範一下用法，遇到這問題時別困擾太久：

a = 'abcde' # 用 next() 一個個拿： b = reversed(a) print(next(b), end=' ') print(next(b), end=' ') print(next(b), end=' ') print(next(b), end=' ') print(next(b), end=' ') print() # 跑迭代： for n in reversed(a): print(n, end=' ') print() # 直接拆解： print(*reversed(a)) # 調用資料所屬物件的功能，例如本例是字串： print(' '.join(reversed(a)))

e d c b a
e d c b a
e d c b a
e d c b a

封裝、繼承、多型

# 封裝 class S: __g = 0 def __init__(self): self.__g = 111 def f(self, x): print(self.__g + x) # 繼承 class T(S): g = 111 def f(self): super().f(self.g) # 多型 # 動態語言本身就已基於多型，並不是只透過類別才能使用多型。 # 物件 a = T() a.g = 222 a.f()

333

類別裡的函式，一定要有第一個參數，通常命名為 self。

以 __ 開頭的變數，無法從外部取用，達到封裝資料的目的。不以 __ 開頭的變數，就可以從外部存取。

多重繼承

class S1: def f1(self): print('AAA') class S2: def f2(self): print('BBB') class S3(S1, S2): def f3(self): print('CCC') a = S3() a.f1() a.f2() a.f3()

AAA
BBB
CCC

函式多載

Python 沒有參數不同就視為不同函式的功能，通常用預設參數的方式來表現，但還是沒有多載那樣方便：

class S: def f(self, x=None, y=None): if x and y: print('%s, %s.' % (x, y)) elif x: print(x + '!') else: print('Hello.') a = S() a.f() a.f('Ahoy') a.f('Holla', 'if ya hear me')

Hello.
Ahoy!
Holla, if ya hear me.

運算子覆載

class S: g = '*' def __add__(self, x): self.g *= x a = S() a + 5 print(a.g)

*****

其它可以覆載的符號有：__sub__、__mul__、__matmul__、__truediv__、__floordiv__、__mod__、__divmod__、__pow__、__lshift__、__rshift__、__and__、__xor__、__or__，以及不是符號，但覆載運算子時常一起覆載的 __str__，即物件導向程式設計常見的 toString()。

Module

每個原始碼檔案就是一個模組（module），可在其它原始碼檔案用 impoer 指令載入使用。解譯器載入模組時，會編譯成 *.pyc 檔案，讓該模組再被使用時提升執行效率。

Package

用資料夾整理這些模組叫做套件（package），每個資料夾可以建立名為 __init__.py 的檔案，用來處理初始化工作，因為解譯器在載入時會先找看看有沒有 __init__.py 可以執行。

宣告這是 Python 格式的可執行檔

#!/usr/bin/python3 print('Hello, world!')
在 Unix-like 作業系統，會根據文件開頭的這段敘述，判斷該用哪個指令工具執行。在 Windows 作業系統的話，是根據附檔名來判斷用哪個應用軟體開啟，不寫也可以。

設定字元編碼

#coding=Big5 print('啥米？你用大五碼！')
Python 3 預設使用 Unicode 編碼系統，如果你的程式碼以 Big5 字元編碼保存，程式將無法執行。這時可以如範例設定使用 Big5 字元編碼。

但強烈建議用 UTF-8 保存程式碼，因為 Python 3 特性之一，就是全面改用 Unicode 編碼系統，字串物件與相關函式都針對 Unicode 重新設計，用 Big5 常常會遇到需要轉碼的問題，自找麻煩。

import 並不是開頭宣告

import 可以在任何位置中使用，甚至有些模組的 import 是在 try.. except..，並不是開頭宣告的一環。

舊的字串格式化更多語法符號

語法：

填充字元 對齊符號 正負號 # 0 寬度 千位數分隔號 .小數位數 型態

新的字串格式化語法進階功能

可用 ^ < > 分别表示置中、置左、置右，後面可以用數字表示寬度。

可用 : 設定填充的符號或字元，預設為空白字元。