本系列文章是我學(xué)習(xí)Python3.9的官方tutorial的筆記，大部分來源于官網(wǎng)的中文翻譯，但由于該翻譯有些部分實在太差和啰嗦，我做了很多刪除和修改，還有部分原文講不明白的，我參考其他資料增加了進一步闡述說明。

3.1 編程的第一步

我們可以將 Python 用于更復(fù)雜的任務(wù)，而不是僅僅簡單地對某個類型進行操作。 例如，我們可以編寫一個 斐波那契數(shù)列 的程序:

>>> # Fibonacci series:
... # the sum of two elements defines the next
... a, b = 0, 1
>>> while a < 10:
...     print(a)
...     a, b = b, a+b
...
0
1
1
2
3
5
8

這個例子引入了幾個新的特點:

• 第一行含有一個 多重賦值: 變量 a 和 b 同時得到了新值 0 和 1. 最后一行又用了一次多重賦值, 這體現(xiàn)出了右邊的表達式在賦值發(fā)生之前會先被求值。右邊的表達式是從左到右被求值的。
• while 循環(huán)只要它的條件（這里指： a < 10）保持為真就會一直執(zhí)行。Python 和 C 一樣，任何非零整數(shù)都為真；零為假。這個條件也可以是字符串或是列表的值，事實上任何序列都可以；長度非零就為真，空序列就為假。
• 循環(huán)體 是 縮進的 ：縮進是 Python 組織語句的方式。在交互式命令行里，你得給每個縮進的行敲下 Tab 鍵或者（多個）空格鍵。所有像樣的文本編輯器都有自動縮進的設(shè)置。交互式命令行里，當(dāng)一個組合的語句輸入時, 需要在最后敲一個空白行表示完成（因為語法分析器猜不出來你什么時候打的是最后一行）。注意，在同一塊語句中的每一行，都要縮進相同的長度。
• print() 函數(shù)將所有傳進來的參數(shù)值打印出來. 它和直接輸入你要顯示的表達式(比如我們之前在計算器的例子里做的)不一樣， print() 能處理多個參數(shù)，包括浮點數(shù)，字符串。 字符串會打印不帶引號的內(nèi)容, 并且在參數(shù)項之間會插入一個空格, 這樣你就可以很好的格式化, 像這樣:

>>> i = 256*256
>>> print('The value of i is', i)
The value of i is 65536

關(guān)鍵字參數(shù) end 可以用來取消輸出后面的換行, 或是用另外一個字符串來結(jié)尾:

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

3.2 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')
...
More

可以有零個或多個 elif 部分，以及一個可選的 else 部分。 關(guān)鍵字 'elif' 是 'else if' 的縮寫，適合用于避免過多的縮進。

3.3 for語句

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

在遍歷集合時修改該集合可能得到錯誤的結(jié)果。通常，更好的做法是循環(huán)遍歷該集合的副本或創(chuàng)建新集合：

# Strategy:  Iterate over a copy
for user, status in users.copy().items():
    if status == 'inactive':
        del users[user]

# Strategy:  Create a new collection
active_users = {}
for user, status in users.items():
    if status == 'active':
        active_users[user] = status

3.4 range()函數(shù)

如果你確實需要遍歷一個數(shù)字序列，內(nèi)置函數(shù) range() 會派上用場:

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

給定的終止數(shù)值并不在要生成的序列里；range(10) 會生成10個值，并且是以合法的索引生成一個長度為10的序列。range也可以以另一個數(shù)字開頭，或者以指定的幅度增加（甚至是負數(shù)；有時這也被叫做 '步進'）

range(5, 10)
   5, 6, 7, 8, 9

range(0, 10, 3)
   0, 3, 6, 9

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

如果你只打印 range，會出現(xiàn)奇怪的結(jié)果:

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

range() 所返回的對象在許多方面表現(xiàn)得像一個列表，但實際上卻并不是。此對象會在你迭代它時基于所希望的序列返回連續(xù)的項，但它沒有真正生成列表，這樣就能節(jié)省空間。

我們稱這樣對象為 iterable，函數(shù)和結(jié)構(gòu)期望從中獲取連續(xù)的項直到所提供的項全部耗盡。 我們已經(jīng)看到 for 語句就是這樣一種結(jié)構(gòu)，而接受可迭代對象的函數(shù)的一個例子是 sum():

>>> sum(range(4))  # 0 + 1 + 2 + 3
6

稍后我們將看到更多返回可迭代對象以及將可迭代對象作為參數(shù)的函數(shù)。 最后，也許你會很好奇如何從一個指定范圍內(nèi)獲取一個列表。 以下是解決方案：

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

3.5 break 和 continue 語句，以及循環(huán)中的 else 子句

break 語句，和 C 中的類似，用于跳出最近的 for 或 while 循環(huán).

循環(huán)語句可能帶有 else 子句；它會在循環(huán)耗盡了可迭代對象 (使用 for) 或循環(huán)條件變?yōu)榧僦?(使用 while) 時被執(zhí)行，但不會在循環(huán)被 break 語句終止時被執(zhí)行。 以下搜索素數(shù)的循環(huán)就是這樣的一個例子:

>>> 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

當(dāng)和循環(huán)一起使用時，else 子句與 try 語句中的 else 子句的共同點多于 if 語句中的同類子句: try 語句中的 else 子句會在未發(fā)生異常時執(zhí)行，而循環(huán)中的 else 子句則會在未發(fā)生 break 時執(zhí)行。 有關(guān) try 語句和異常的更多信息，請參閱 處理異常。

continue 語句也是借鑒自 C 語言，表示繼續(xù)循環(huán)中的下一次迭代:

>>> for num in range(2, 10):
...     if num % 2 == 0:
...         print("Found an even number", num)
...         continue
...     print("Found an odd number", num)
Found an even number 2
Found an odd number 3
Found an even number 4
Found an odd number 5
Found an even number 6
Found an odd number 7
Found an even number 8
Found an odd number 9

3.6 pass語句

pass 語句什么也不做。當(dāng)語法上需要一個語句，但程序需要什么動作也不做時，可以使用它。例如:

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

這通常用于創(chuàng)建最小的類:

>>> class MyEmptyClass:
...     pass
...

pass 的另一個可以使用的場合是在你編寫新的代碼時作為一個函數(shù)或條件子句體的占位符，允許你保持在更抽象的層次上進行思考。 pass 會被靜默地忽略:

>>> def initlog(*args):
...     pass   # Remember to implement this!
...

3.7 定義函數(shù)

我們可以創(chuàng)建一個輸出任意范圍內(nèi) Fibonacci 數(shù)列的函數(shù):

>>> def fib(n):    # write Fibonacci series up to 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

關(guān)鍵字 def 引入一個函數(shù) 定義。其后是函數(shù)名稱和帶括號的形式參數(shù)列表。構(gòu)成函數(shù)體的語句從下一行開始，并且必須縮進。
函數(shù)體的第一個語句可以是一個字符串文字（可選的）；這個字符串文字是函數(shù)的文檔字符串或 docstring 。
函數(shù)的執(zhí)行會引入一個用于函數(shù)局部變量的新符號表。 更確切地說，函數(shù)中所有的變量賦值都將存儲在局部符號表中；而變量引用會首先在局部符號表中查找，然后是外層函數(shù)的局部符號表，再然后是全局符號表，最后是內(nèi)置名稱的符號表。 因此，全局變量和外層函數(shù)的變量不能在函數(shù)內(nèi)部直接賦值（除非是在 global 語句中定義的全局變量，或者是在 nonlocal 語句中定義的外層函數(shù)的變量），盡管它們可以被引用。
在函數(shù)被調(diào)用時，實際參數(shù)（實參）會被引入被調(diào)用函數(shù)的本地符號表中；因此，實參是通過按值調(diào)用傳遞的（其中值始終是對象引用而不是對象的值）。當(dāng)一個函數(shù)調(diào)用另外一個函數(shù)時，將會為該調(diào)用創(chuàng)建一個新的本地符號表。
函數(shù)定義會將函數(shù)名稱與函數(shù)對象在當(dāng)前符號表中進行關(guān)聯(lián)。 解釋器會將該名稱所指向的對象識別為用戶自定義函數(shù)。 其他名稱也可指向同一個函數(shù)對象并可被用來訪問訪函數(shù):

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

如果你學(xué)過其他語言，你可能會認為 fib 不是函數(shù)而是一個過程，因為它并不返回值。事實上，即使沒有 return 語句的函數(shù)也會返回一個值，盡管它是一個相當(dāng)無聊的值。這個值稱為 None （它是內(nèi)置名稱）。一般來說解釋器不會打印出單獨的返回值 None ，如果你真想看到它，你可以使用 print()

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

寫一個返回斐波那契數(shù)列的列表（而不是把它打印出來）的函數(shù)，非常簡單:

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

此示例中，像往常一樣，演示了一些新的 Python 功能:

• return 語句會從函數(shù)內(nèi)部返回一個值。 不帶表達式參數(shù)的 return 會返回 None。 函數(shù)執(zhí)行完畢退出也會返回 None。
• result.append(a) 語句調(diào)用了列表對象 result 的 方法 。方法是“屬于”一個對象的函數(shù)，它被命名為 obj.methodname ，其中 obj 是某個對象（也可能是一個表達式）， methodname 是由對象類型中定義的方法的名稱。示例中的方法 append() 是為列表對象定義的；它會在列表的最后添加一個新的元素。在這個示例中它相當(dāng)于 result = result + [a] ，但更高效。

3.8 函數(shù)定義的更多形式

3.8.1 參數(shù)默認值

給參數(shù)指定默認值，這樣創(chuàng)建的函數(shù)，可以用更少的參數(shù)調(diào)用，比如:

def ask_ok(prompt, retries=4, reminder='Please try again!'):
    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 ValueError('invalid user response')
        print(reminder)

這個函數(shù)可以通過幾種方式調(diào)用:

• 只給出必需的參數(shù)：ask_ok('Do you really want to quit?')
• 給出一個可選的參數(shù)：ask_ok('OK to overwrite the file?', 2)
• 或者給出所有的參數(shù)：ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')

這個示例還介紹了 in 關(guān)鍵字。它可以測試一個序列是否包含某個值。
默認值是在 定義過程 中在函數(shù)定義處計算的，所以

i = 5

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

i = 6
f()

會打印 5。
重要警告： 默認值只會執(zhí)行一次。這條規(guī)則在默認值為可變對象（列表、字典以及大多數(shù)類實例）時很重要。比如，下面的函數(shù)會存儲在后續(xù)調(diào)用中傳遞給它的參數(shù):

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

def g(a, b=0):
    b=a+b
    return b

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

這將打印出

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

如果你不想要在后續(xù)調(diào)用之間共享默認值，你可以這樣寫這個函數(shù):

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

3.8.2 關(guān)鍵字參數(shù)

也可以使用形如 kwarg=value 的 關(guān)鍵字參數(shù) 來調(diào)用函數(shù)。例如下面的函數(shù):

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, "!")

接受一個必需的參數(shù)（voltage）和三個可選的參數(shù)（state, action，和 type）。這個函數(shù)可以通過下面的任何一種方式調(diào)用:

parrot(1000)                                          # 1 positional argument
parrot(voltage=1000)                                  # 1 keyword argument
parrot(voltage=1000000, action='VOOOOOM')             # 2 keyword arguments
parrot(action='VOOOOOM', voltage=1000000)             # 2 keyword arguments
parrot('a million', 'bereft of life', 'jump')         # 3 positional arguments
parrot('a thousand', state='pushing up the daisies')  # 1 positional, 1 keyword

但下面的函數(shù)調(diào)用都是無效的:

parrot()                     # required argument missing
parrot(voltage=5.0, 'dead')  # non-keyword argument after a keyword argument
parrot(110, voltage=220)     # duplicate value for the same argument
parrot(actor='John Cleese')  # unknown keyword argument

當(dāng)存在一個形式為 **name 的最后一個形參時，它會接收一個字典 (參見 映射類型 --- dict)，其中包含除了與已有形參相對應(yīng)的關(guān)鍵字參數(shù)以外的所有關(guān)鍵字參數(shù)。 這可以與一個形式為 *name的形參組合使用 (*name 必須出現(xiàn)在 **name 之前，*name作為一個元組變量接收位置參數(shù)，**name作為一個字典變量接收關(guān)鍵字參數(shù)。) 例如，如果我們這樣定義一個函數(shù):

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)
    for kw in keywords:
        print(kw, ":", keywords[kw])

它可以像這樣調(diào)用:

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.
----------------------------------------
shopkeeper : Michael Palin
client : John Cleese
sketch : Cheese Shop Sketch

注意打印時關(guān)鍵字參數(shù)的順序與調(diào)用函數(shù)時提供它們的順序是相匹配的。

3.8.3 特殊參數(shù)

def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):
      -----------    ----------     ----------
        |             |                  |
        |        Positional or keyword   |
        |                                - Keyword only
         -- Positional only

在這里 / 和 * 是可選的。 如果使用這些符號則表明可以通過何種形參將參數(shù)值傳遞給函數(shù)：僅限位置、位置或關(guān)鍵字，以及僅限關(guān)鍵字。 關(guān)鍵字形參也被稱為命名形參。

3.8.3.1 位置或關(guān)鍵字參數(shù)

如果函數(shù)定義中未使用 / 和 *，則參數(shù)可以按位置或按關(guān)鍵字傳遞給函數(shù)。

3.8.3.2 僅限位置參數(shù)

如果是 僅限位置 的形參，則其位置是重要的，并且該形參不能作為關(guān)鍵字傳入。 僅限位置形參要放在 / (正斜杠) 之前。 這個 / 被用來從邏輯上分隔僅限位置形參和其它形參。 如果函數(shù)定義中沒有 /，則表示沒有僅限位置形參。

3.8.3.3 僅限關(guān)鍵字參數(shù)

要將形參標(biāo)記為 僅限關(guān)鍵字，即指明該形參必須以關(guān)鍵字參數(shù)的形式傳入，應(yīng)在參數(shù)列表的第一個 僅限關(guān)鍵字 形參之前放置一個 *。

最后，請考慮這個函數(shù)定義，它的位置參數(shù) name 和 **kwds 之間由于存在關(guān)鍵字名稱 name 而可能產(chǎn)生潛在沖突:

def foo(name, **kwds):
    return 'name' in kwds

任何調(diào)用都不可能讓它返回 True，因為關(guān)鍵字 'name' 將總是綁定到第一個形參。 例如:

>>> foo(1, **{'name': 2})
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() got multiple values for argument 'name'
>>>

但使用 / (僅限位置參數(shù)) 就可能做到，因為它允許 name 作為位置參數(shù)，也允許 'name' 作為關(guān)鍵字參數(shù)的關(guān)鍵字名稱:

def foo(name, /, **kwds):
    return 'name' in kwds
>>> foo(1, **{'name': 2})
True

換句話說，僅限位置形參的名稱可以在 **kwds 中使用而不產(chǎn)生歧義。

作為指導(dǎo)：

• 如果你希望形參名稱對用戶來說不可用，則使用僅限位置形參。 這適用于形參名稱沒有實際意義，以及當(dāng)你希望強制規(guī)定調(diào)用時的參數(shù)順序，或是需要同時收受一些位置形參和任意關(guān)鍵字形參等情況。
• 當(dāng)形參名稱有實際意義，以及顯式指定形參名稱可使函數(shù)定義更易理解，或者當(dāng)你想要防止用戶過于依賴傳入?yún)?shù)的位置時，則使用僅限關(guān)鍵字形參。
• 對于 API 來說，使用僅限位置形參可以防止形參名稱在未來被修改時造成破壞性的 API 變動。

3.8.4 任意的參數(shù)列表

最后，最不常用的選項是可以使用任意數(shù)量的參數(shù)調(diào)用函數(shù)。這些參數(shù)會被包含在一個元組里（參見 元組和序列 ）。在可變數(shù)量的參數(shù)之前，可能會出現(xiàn)零個或多個普通參數(shù)。

def write_multiple_items(file, separator, *args):
    file.write(separator.join(args))

一般來說，這些 可變參數(shù) 在形式參數(shù)列表的末尾，因為它們收集傳遞給函數(shù)的所有剩余輸入?yún)?shù)。出現(xiàn)在 *args 參數(shù)之后的任何形式參數(shù)都是 ‘僅關(guān)鍵字參數(shù)’，也就是說它們只能作為關(guān)鍵字參數(shù)而不能是位置參數(shù)。:

>>> def concat(*args, sep="/"):
...     return sep.join(args)
...
>>> concat("earth", "mars", "venus")
'earth/mars/venus'
>>> concat("earth", "mars", "venus", sep=".")
'earth.mars.venus'

3.8.5 解包參數(shù)列表

例如，內(nèi)置的 range() 函數(shù)需要單獨的 start 和 stop 參數(shù)，可以使用 * 操作符 來編寫函數(shù)調(diào)用以便從列表或元組中解包參數(shù):

>>> list(range(3, 6))            # normal call with separate arguments
[3, 4, 5]
>>> args = [3, 6]
>>> list(range(*args))            # call with arguments unpacked from a list
[3, 4, 5]

同樣的方式，字典可使用 ** 操作符 來提供關(guān)鍵字參數(shù):

>>> 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 !

3.8.6 Lambda 表達式

可以用 lambda 關(guān)鍵字來創(chuàng)建一個小的匿名函數(shù)。
lambda a, b: a+b這個函數(shù)返回兩個參數(shù)的和。
Lambda函數(shù)可以在需要函數(shù)對象的任何地方使用。它們在語法上限于單個表達式。從語義上來說，它們只是正常函數(shù)定義的語法糖。與嵌套函數(shù)定義一樣，lambda函數(shù)可以引用所包含域的變量:

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

上面的例子使用一個lambda表達式來返回一個函數(shù)。另一個用法是傳遞一個小函數(shù)作為參數(shù):

>>> pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
>>> pairs.sort(key=lambda pair: pair[1]) # 按照tuple的第二個值進行排序
>>> pairs
[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

3.8.7 文檔字符串

以下是有關(guān)文檔字符串的內(nèi)容和格式的一些約定。

第一行應(yīng)該是函數(shù)功能的簡要概述。為簡潔起見，它不應(yīng)顯式聲明函數(shù)的名稱或類型，因為這些可通過其他方式獲得（除非名稱恰好是描述函數(shù)操作的動詞）。這一行應(yīng)以大寫字母開頭，以句點結(jié)尾。

如果文檔字符串中有更多行，則第二行應(yīng)為空白，從而在視覺上將摘要與其余描述分開。后面幾行應(yīng)該是一個或多個段落，描述對象的調(diào)用約定，它的副作用等。

下面是一個多行文檔字符串的例子:

>>> def my_function():
...     """Do nothing, but document it.
...
...     No, really, it doesn't do anything.
...     """
...     pass
...
>>> print(my_function.__doc__)
Do nothing, but document it.

    No, really, it doesn't do anything.

3.8.8 函數(shù)標(biāo)注

函數(shù)標(biāo)注 是關(guān)于用戶自定義函數(shù)中使用的類型的完全可選元數(shù)據(jù)信息。
函數(shù)標(biāo)注 以字典的形式存放在函數(shù)的 __annotations__ 屬性中，并且不會影響函數(shù)的任何其他部分。 形參標(biāo)注的定義方式是在形參名稱后加上冒號，后面跟一個表達式，該表達式會被求值為標(biāo)注的值。 返回值標(biāo)注的定義方式是加上一個組合符號 ->，后面跟一個表達式，該標(biāo)注位于形參列表和表示 def 語句結(jié)束的冒號之間。 下面的示例有一個位置參數(shù)，一個關(guān)鍵字參數(shù)以及返回值帶有相應(yīng)標(biāo)注:

>>> def f(ham: str, eggs: str = 'eggs') -> str:
...     print("Annotations:", f.__annotations__)
...     print("Arguments:", ham, eggs)
...     return ham + ' and ' + eggs
...
>>> f('spam')
Annotations: {'ham': <class 'str'>, 'return': <class 'str'>, 'eggs': <class 'str'>}
Arguments: spam eggs
'spam and eggs'

3.9 小插曲：編碼風(fēng)格

對于Python，PEP 8 已經(jīng)成為大多數(shù)項目所遵循的風(fēng)格指南；它促進了一種非常易讀且令人賞心悅目的編碼風(fēng)格。每個Python開發(fā)人員都應(yīng)該在某個時候閱讀它；以下是為你提取的最重要的幾個要點：

• 使用4個空格縮進，不要使用制表符。
  4個空格是一個在小縮進（允許更大的嵌套深度）和大縮進（更容易閱讀）的一種很好的折中方案。制表符會引入混亂，最好不要使用它。
• 換行，使一行不超過79個字符。
  這有助于使用小型顯示器的用戶，并且可以在較大的顯示器上并排放置多個代碼文件。
• 使用空行分隔函數(shù)和類，以及函數(shù)內(nèi)的較大的代碼塊。
• 如果可能，把注釋放到單獨的一行。
• 使用文檔字符串。
• 在運算符前后和逗號后使用空格，但不能直接在括號內(nèi)使用： a = f(1, 2) + g(3, 4)。
• 以一致的規(guī)則為你的類和函數(shù)命名；按照慣例應(yīng)使用 UpperCamelCase 來命名類，而以 lowercase_with_underscores 來命名函數(shù)和方法。 始終應(yīng)使用 self 來命名第一個方法參數(shù) (有關(guān)類和方法的更多信息請參閱 初探類)。
• 如果你的代碼旨在用于國際環(huán)境，請不要使用花哨的編碼。Python 默認的 UTF-8 或者純 ASCII 在任何情況下都能有最好的表現(xiàn)。
• 同樣，哪怕只有很小的可能，遇到說不同語言的人閱讀或維護代碼，也不要在標(biāo)識符中使用非ASCII字符。