更新時間：2018-06-14

《Python指南》原文在這裏。本篇筆記主要是劃重點。

Python 3.6.3

1、簡單入門

1.1 編碼

默認情況下，Python 源文件是 UTF-8 編碼。

你也可以為源文件指定不同的字符編碼。

# -*- coding: encoding -*-

1.2 註釋

Python 中的註釋以 # 字符起始，直至實際的行尾。類似java的//單行註釋

1.3 算術運算

整數的類型是int,浮點數的類型是float。整數和浮點數的混合計算中，整數會被轉換為浮點數。

除法(/)永遠返回一個浮點數。

floor除法(//)並且得到整數結果（丟掉任何小數部分）。

%用來計算余數。

**運算符計算冪乘方。

5 ** 2 # 5的2次方，結果是25

變量在使用前必須 “定義”(賦值)。

除了 int 和 float，Python 還支持其它數字類型，例如 Decimal 和 Fraction。

1.4 字符串

Python提供了幾種不同方式表示的字符串。它們可以用單引號 (‘...‘) 或雙引號 ("...") 標識。\ 可以用來轉義引號。

當字符中帶有\時可能會出現錯誤，例如\n會換行。你可以使用 原始字符串，方法是在第一個引號前面加上一個 r

>>> print(r‘C:\some\name‘)
C:\some\name

字符串文本能夠分成多行。一種方法是使用三引號："""..."""

行尾換行符會被自動包含到字符串中，但是可以在行尾加上 \ 來避免這個行為。下面的示例： 可以使用反斜杠為行結尾的連續字符串，它表示下一行在邏輯上是本行的後續內容:

print("""Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
""")

將輸出以下內容：

Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
 

字符串可以由 + 操作符連接(粘到一起)，可以由 * 表示重復：

>>> 3 * ‘un‘ + ‘ium‘
‘unununium‘

相鄰的兩個字符串文本自動連接在一起：

>>> ‘Py‘ ‘thon‘
‘Python‘

它只用於兩個字符串文本，不能用於字符串表達式：

>>> prefix = ‘Py‘
>>> prefix ‘thon‘
  ...
SyntaxError: invalid syntax
>>> (‘un‘ * 3) ‘ium‘
  ...
SyntaxError: invalid syntax

字符串也可以被截取(檢索)。字符串的第一個字符索引為 0 。Python沒有單獨的字符類型；一個字符就是一個簡單的長度為1的字符串。:

>>> word = ‘Python‘
>>> word[0]  # 獲取索引為0的字符
‘P‘

索引也可以是負數，這將導致從右邊開始計算。例如：

>>> word = ‘Python‘
>>> word[-1]
‘n‘

請註意 -0 實際上就是 0。

除了索引，還支持 切片。索引用於獲得單個字符，切片 讓你獲得一個子字符串：

>>> word = ‘Python‘
>>> word[0:2] # 截取索引從0開始到1（2的前一位）的字符串
‘Py‘

切片的索引有非常有用的默認值；省略的第一個索引默認為零，省略的第二個索引默認為切片的字符串的大小。

>>> word = ‘Python‘
>>> word[:2]
‘Py‘
>>> word[4:]
‘on‘

試圖使用太大的索引會導致錯誤：

IndexError: string index out of range

Python 能夠優雅地處理那些沒有意義的切片索引：一個過大的索引值(即下標值大於字符串實際長度)將被字符串實際長度所代替，當上邊界比下邊界大時(即切片左值大於右值)就返回空字符串。

>>> word = ‘Python‘
>>> word[4:42]
‘on‘
>>> word[42:]
‘‘

Python字符串不可以被更改 — 它們是不可變的。因此，賦值給字符串索引的位置會導致錯誤：

>>> word[0] = ‘J‘
  ...
TypeError: ‘str‘ object does not support item assignment

內置函數 len() 返回字符串長度：

>>> s = ‘supercalifragilisticexpialidoc‘
>>> len(s)
30

1.5 列表（list）

Python 有幾個復合數據類型，用於表示其它的值。最通用的是list，它可以寫作中括號之間的一列逗號分隔的值。列表的元素不必是同一類型。

>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]

就像字符串(以及其它所有內建的 序列 類型)一樣，列表可以被索引和切片：

>>> squares[0]
1
>>> squares[-1]
25
>>> squares[-3:]  # 切片返回一個新list（淺拷貝）
[9, 16, 25]

列表也支持連接這樣的操作：

>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

你還可以使用 append() 方法在列表的末尾添加新的元素：

>>> cubes = [1, 8, 27, 65, 125]
>>> cubes.append(216)
>>> cubes.append(7 ** 3)
>>> cubes
[1, 8, 27, 64, 125, 216, 343]

也可以對切片賦值，此操作可以改變列表的尺寸，或清空它：

>>> letters = [‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘, ‘f‘, ‘g‘]
>>> letters[2:5] = [‘C‘, ‘D‘, ‘E‘]
>>> letters
[‘a‘, ‘b‘, ‘C‘, ‘D‘, ‘E‘, ‘f‘, ‘g‘]

>>> letters[2:5] = []
>>> letters
[‘a‘, ‘b‘, ‘f‘, ‘g‘]

>>> # 清空list
>>> letters[:] = []
>>> letters
[]

內置函數 len() 同樣適用於列表：

>>> letters = [‘a‘, ‘b‘, ‘c‘, ‘d‘]
>>> len(letters)
4

允許嵌套列表：

>>> a = [‘a‘, ‘b‘, ‘c‘]
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[[‘a‘, ‘b‘, ‘c‘], [1, 2, 3]]
>>> x[0]
[‘a‘, ‘b‘, ‘c‘]
>>> x[0][1]
‘b‘

1.6 更復雜的例子

例如，我們可以寫一個生成菲波那契子序列的程序，如下所示：

>>> # Fibonacci series:
... a, b = 0, 1
>>> while b < 10:
...     print(b)
...     a, b = b, a+b

這個例子介紹了幾個新功能。

• 第一行包括了一個 多重賦值：變量 a 和 b 同時獲得了新的值 0 和 1 最後一行又使用了一次。
• 條件（這裏是 b < 10 ）為 true 時， while 循環執行。在 Python 中，類似於 C，任何非零整數都是 true；0 是 false。條件也可以是字符串或列表，實際上可以是任何序列；所有長度不為零的是 true，空序列是 false。
• 循環體是縮進的：縮進是 Python 組織語句的方法。Python (還)不提供集成的行編輯功能，所以你要為每一個縮進行輸入 TAB 或空格。
• 交互式錄入復合語句時，必須在最後輸入一個空行來標識結束（因為解釋器沒辦法猜測你輸入的哪一行是最後一行），需要 註意的是同一個語句塊中的每一行必須縮進同樣數量的空白。
• 關鍵字 print() 語句輸出給定表達式的值。

用一個逗號結尾就可以禁止輸出換行:

>>> a, b = 0, 1
>>> while b < 1000:
...     print(b, end=‘,‘)
...     a, b = b, a+b
...
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

2、深入 Python 流程控制

2.1 if 語句

>>> x = int(input("Please enter an integer: "))
Please enter an integer: 42
>>> if x < 0:
...      x = 0
...      print(‘Negative changed to zero‘)
... elif x == 0:
...      print(‘Zero‘)
... elif x == 1:
...      print(‘Single‘)
... else:
...      print(‘More‘)

可能會有零到多個 elif 部分，else 是可選的。

2.2 for 語句

Python 的 for 語句可以依據任意序列（鏈表或字符串）中的子項，按它們在序列中的順序來進行叠代。

>>> # Measure some strings:
... words = [‘cat‘, ‘window‘, ‘defenestrate‘]
>>> for w in words:
...     print(w, len(w))
...
cat 3
window 6
defenestrate 12

在叠代過程中修改叠代序列不安全（只有在使用鏈表這樣的可變序列時才會有這樣的情況）。如果你想要修改你叠代的序列（例如，復制選擇項），你可以叠代它的復本。使用切割標識就可以很方便的做到這一點:

>>> for w in words[:]:  # 循環一個完整的 list副本
...     if len(w) > 6:
...         words.insert(0, w)
...
>>> words
[‘defenestrate‘, ‘cat‘, ‘window‘, ‘defenestrate‘]

2.3. range() 函數

如果你需要一個數值序列，內置函數 range() 會很方便，它生成一個等差級數鏈表:

>>> for i in range(5):
...     print(i)
...
0
1
2
3
4

range(10) 生成了一個包含 10 個值的鏈表，它用鏈表的索引值填充了這個長度為 10 的列表，所生成的鏈表中不包括範圍中的結束值。也可以讓 range() 操作從另一個數值開始，或者可以指定一個不同的步進值（甚至是負數，有時這也被稱為 “步長”）:

range(5, 10)
   5 到 9

range(0, 10, 3)// (從幾開始,到幾,每次增加多少)
   0, 3, 6, 9

range(-10, -100, -30)
  -10, -40, -70

需要叠代鏈表索引的話，如下所示結合使 用 range() 和 len()：

>>> a = [‘Mary‘, ‘had‘, ‘a‘, ‘little‘, ‘lamb‘]
>>> for i in range(len(a)):
...     print(i, a[i])
...
0 Mary
1 had
2 a
3 little
4 lamb

不過，這種場合可以方便的使用 enumerate():

>>> for i, v in enumerate([‘tic‘, ‘tac‘, ‘toe‘]):
...     print(i, v)
...
0 tic
1 tac
2 toe

如果你只是打印一個序列的話會發生奇怪的事情:

>>> print(range(10))
range(0, 10)

在不同方面 range() 函數返回的對象表現為它是一個列表，但事實上它並不是。當你叠代它時，它是一個能夠像期望的序列返回連續項的對象；但為了節省空間，它並不真正構造列表。

我們稱此類對象是 可叠代的，即適合作為那些期望從某些東西中獲得連續項直到結束的函數或結構的一個目標（參數）。我們已經見過的 for 語句就是這樣一個叠代器。list() 函數是另外一個（ 叠代器 ），它從可叠代（對象）中創建列表:

>>> list(range(5))
[0, 1, 2, 3, 4]

2.4. break 和 continue 語句, 以及循環中的 else 子句

循環可以有一個 else 子句；它在循環叠代完整個列表（對於 for ）或執行條件為 false （對於 while ）時執行，但循環被 break 中止的情況下不會執行。以下搜索素數的示例程序演示了這個子句:

>>> for n in range(2, 10):
...     for x in range(2, n):
...         if n % x == 0:
...             print(n, ‘equals‘, x, ‘*‘, n//x)
...             break
...     else:
...         # loop fell through without finding a factor
...         print(n, ‘is a prime number‘)
...
2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3

2.5. pass 語句

pass 語句什麽也不做。它用於那些語法上必須要有什麽語句，但程序什麽也不做的場合，例如:

>>> while True:
...     pass  # Busy-wait for keyboard interrupt (Ctrl+C)
...

2.6. 定義函數

我們可以創建一個用來生成指定邊界的斐波那契數列的函數:

>>> def fib(n):
...     """Print a Fibonacci series up to n."""
...     a, b = 0, 1
...     while a < n:
...         print(a, end=‘ ‘)
...         a, b = b, a+b
...     print()
...
>>> # Now call the function we just defined:
... fib(2000)
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

關鍵字 def 引入了一個函數 定義。在其後必須跟有函數名和包括形式參數的圓括號。函數體語句從下一行開始，必須是縮進的。

函數體的第一行語句可以是可選的字符串文本，這個字符串是函數的文檔字符串，或者稱為 docstring。在你的代碼中包含 docstrings 是一個好的實踐，讓它成為習慣吧。

函數 調用 會為函數局部變量生成一個新的符號表。確切的說，所有函數中的變量賦值都是將值存儲在局部符號表。變量引用首先在局部符號表中查找，然後是包含函數的局部符號表，然後是全局符號表，最後是內置名字表。因此，全局變量不能在函數中直接賦值（除非用 global 語句命名），盡管他們可以被引用。

函數引用的實際參數在函數調用時引入局部符號表，因此，實參總是 傳值調用 （這裏的 值 總是一個對象 引用 ，而不是該對象的值）。[1] 一個函數被另一個函數調用時，一個新的局部符號表在調用過程中被創建。

一個函數定義會在當前符號表內引入函數名。函數名指代的值（即函數體）有一個被 Python 解釋器認定為 用戶自定義函數 的類型。 這個值可以賦予其他的名字（即變量名），然後它也可以被當做函數使用。這可以作為通用的重命名機制:

>>> fib
<function fib at 10042ed0>
>>> f = fib
>>> f(100)
0 1 1 2 3 5 8 13 21 34 55 89

如果你使用過其他語言，你可能會反對說：fib 不是一個函數，而是一個方法，因為它並不返回任何值。事實上，沒有 return 語句的函數確實會返回一個值，雖然是一個相當令人厭煩的值（指 None ）。這個值被稱為 None （這是一個內建名稱）。如果 None 值是唯一被書寫的值，那麽在寫的時候通常會被解釋器忽略（即不輸出任何內容）。如果你確實想看到這個值的輸出內容，請使用 print() 函數:

>>> fib(0)
>>> print(fib(0))
None

定義一個返回斐波那契數列數字列表的函數，而不是打印它，是很簡單的:

>>> def fib2(n):
...     """Return a list containing the Fibonacci series up to n."""
...     result = []
...     a, b = 0, 1
...     while a < n:
...         result.append(a)
...         a, b = b, a+b
...     return result
...
>>> f100 = fib2(100)
>>> f100
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

return 語句從函數中返回一個值，不帶表達式的 return 返回 None。

2.7. 深入 Python 函數定義

2.7.1. 默認參數值

最常用的一種形式是為一個或多個參數指定默認值。再使用時有默認值的參數就可以不傳。

def ask_ok(prompt, retries=4, complaint=‘Yes or no, please!‘):
    while True:
        ok = input(prompt)
        if ok in (‘y‘, ‘ye‘, ‘yes‘):
            return True
        if ok in (‘n‘, ‘no‘, ‘nop‘, ‘nope‘):
            return False
        retries = retries - 1
        if retries < 0:
            raise OSError(‘uncooperative user‘)
        print(complaint)

這個函數可以通過幾種不同的方式調用:

只給出必要的參數:

ask_ok(‘Do you really want to quit?‘)

給出一個可選的參數:

ask_ok(‘OK to overwrite the file?‘, 2)

或者給出所有的參數:

ask_ok(‘OK to overwrite the file?‘, 2, ‘Come on, only yes or no!‘)

這個例子還介紹了 in 關鍵字。它測定序列中是否包含某個確定的值。

默認值在函數 定義 作用域被解析，如下所示:

i = 5

def f(arg=i):
    print(arg)

i = 6
f()

將會輸出 5。

重要警告: 默認值只被賦值一次。當默認值是可變對象時會有所不同，比如列表、字典或者大多數類的實例。例如，下面的函數在後續調用過程中會累積（前面）傳給它的參數:

def f(a, L=[]):
    L.append(a)
    return L

print(f(1))
print(f(2))
print(f(3))

這將會輸出：

[1]
[1, 2]
[1, 2, 3]

如果你不想讓默認值在後續調用中累積，你可以像下面一樣定義函數:

def f(a, L=None):
    if L is None:
        L = []
    L.append(a)
    return L

2.7.2. 關鍵字參數

函數可以通過 關鍵字參數 的形式來調用，形如 keyword = value。例如，以下的函數:

def parrot(voltage, state=‘a stiff‘, action=‘voom‘, type=‘Norwegian Blue‘):
    print("-- This parrot wouldn‘t", action, end=‘ ‘)
    print("if you put", voltage, "volts through it.")
    print("-- Lovely plumage, the", type)
    print("-- It‘s", state, "!")

接受一個必選參數 (voltage) 以及三個可選參數 (state, action, 和 type)。可以用以下的任一方法調用:

parrot(1000)
parrot(voltage=1000)
parrot(voltage=1000000, action=‘VOOOOOM‘)
parrot(action=‘VOOOOOM‘, voltage=1000000)
parrot(‘a million‘, ‘bereft of life‘, ‘jump‘)
parrot(‘a thousand‘, state=‘pushing up the daisies‘)

任何參數都不可以多次賦值。下面的示例由於這種限制將失敗:

>>> def function(a):
...     pass
...
>>> function(0, a=0)
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: function() got multiple values for keyword argument ‘a‘

引入一個形如 **name 的參數時，它接收一個字典（參見 Mapping Types — dict ），該字典包含了所有未出現在形式參數列表中的關鍵字參數。這裏可能還會組合使用一個形如 *name （下一小節詳細介紹） 的形式參數，它接收一個元組（下一節中會詳細介紹），包含了所有沒有出現在形式參數列表中的參數值（ *name 必須在 **name 之前出現）。 例如，我們這樣定義一個函數:

def cheeseshop(kind, *arguments, **keywords):
    print("-- Do you have any", kind, "?")
    print("-- I‘m sorry, we‘re all out of", kind)
    for arg in arguments:
        print(arg)
    print("-" * 40)
    keys = sorted(keywords.keys())
    for kw in keys:
        print(kw, ":", keywords[kw])

它可以像這樣調用:

cheeseshop("Limburger", "It‘s very runny, sir.",
           "It‘s really very, VERY runny, sir.",
           shopkeeper="Michael Palin",
           client="John Cleese",
           sketch="Cheese Shop Sketch")

當然它會按如下內容打印:

-- Do you have any Limburger ?
-- I‘m sorry, we‘re all out of Limburger
It‘s very runny, sir.
It‘s really very, VERY runny, sir.
----------------------------------------
client : John Cleese
shopkeeper : Michael Palin
sketch : Cheese Shop Sketch

註意在打印關鍵字參數之前，通過對關鍵字字典 keys() 方法的結果進行排序，生成了關鍵字參數名的列表；如果不這樣做，打印出來的參數的順序是未定義的。

2.7.3. 參數列表的分拆

當你要傳遞的參數已經是一個列表，但要調用的函數卻接受分開一個個的參數值。這時候你要把已有的列表拆開來。例如內建函數 range() 需要要獨立的 start，stop 參數。你可以在調用函數時加一個 * 操作符來自動把參數列表拆開:

>>> list(range(3, 6))   # 直接使用獨立參數
[3, 4, 5]
>>> args = [3, 6]
>>> list(range(*args))  # 從一個list裏拆分參數
[3, 4, 5]

以同樣的方式，可以使用 ** 操作符分拆關鍵字參數為字典:

>>> def parrot(voltage, state=‘a stiff‘, action=‘voom‘):
...     print("-- This parrot wouldn‘t", action, end=‘ ‘)
...     print("if you put", voltage, "volts through it.", end=‘ ‘)
...     print("E‘s", state, "!")
...
>>> d = {"voltage": "four million", "state": "bleedin‘ demised", "action": "VOOM"}
>>> parrot(**d)
-- This parrot wouldn‘t VOOM if you put four million volts through it. E‘s bleedin‘ demised !

2.7.4. Lambda 形式

通過 lambda 關鍵字，可以創建短小的匿名函數。這裏有一個函數返回它的兩個參數的和： lambda a, b: a+b。 Lambda 形式可以用於任何需要的函數對象。出於語法限制，它們只能有一個單獨的表達式。語義上講，它們只是普通函數定義中的一個語法技巧。類似於嵌套函數定義，lambda 形式可以從外部作用域引用變量:

>>> def make_incrementor(n):
...     return lambda x: x + n
...
>>> f = make_incrementor(42)
>>> f(0)
42
>>> f(1)
43

2.8. 編碼風格

1.使用 4 空格縮進，而非 TAB

在小縮進（可以嵌套更深）和大縮進（更易讀）之間，4空格是一個很好的折中。TAB 引發了一些混亂，最好棄用

2.折行以確保其不會超過 79 個字符

這有助於小顯示器用戶閱讀，也可以讓大顯示器能並排顯示幾個代碼文件

3.使用空行分隔函數和類，以及函數中的大塊代碼

4.可能的話，註釋獨占一行

5.統一函數和類命名

推薦類名用 駝峰命名， 函數和方法名用 小寫和_下劃線。總是用self` 作為方法的第一個參數

《Python指南》學習筆記 一