27 個為什麼，幫助你更好的理解Python

選自《Python官方文檔》
https://docs.python.org/zh-cn/3.7/faq/design.html目錄

01. 為什麼使用縮進來分組語句？

Guido van Rossum 認為使用縮進進行分組非常優雅，並且大大提高了普通 Python 程序的清晰度。大多數人在一段時間後就學會並喜歡上這個功能。由於沒有開始/結束括號，因此解析器感知的分組與人類讀者之間不會存在分歧。偶爾 C 程序員會遇到像這樣的代碼片段:

if (x <= y) x++; y--;z++;

如果條件為真，則只執行 x++ 語句，但縮進會使你認為情況並非如此。即使是經驗豐富的 C 程序員有時會長時間盯著它，想知道為什麼即使 x > y ， y 也在減少。因為沒有開始/結束括號，所以 Python 不太容易發生編碼式衝突。在 C 中，括號可以放到許多不同的位置。如果您習慣於閱讀和編寫使用一種風格的代碼，那麼在閱讀（或被要求編寫）另一種風格時，您至少會感到有些不安。許多編碼風格將開始/結束括號單獨放在一行上。這使得程序相當長，浪費了寶貴的屏幕空間，使得更難以對程序進行全面的瞭解。理想情況下，函數應該適合一個屏幕（例如，20--30 行）。20 行 Python 可以完成比 20 行 C 更多的工作。這不僅僅是由於缺少開始/結束括號 -- 缺少聲明和高級數據類型也是其中的原因 -- 但縮進基於語法肯定有幫助。

>>> 1.2 - 1.00.19999999999999996

並且認為這是 Python 中的一個 bug。其實不是這樣。這與 Python 關係不大，而與底層平臺如何處理浮點數字關係更大。CPython 中的 float 類型使用 C 語言的 double 類型進行存儲。float 對象的值是以固定的精度（通常為 53 位）存儲的二進制浮點數，由於 Python 使用 C 操作，而後者依賴於處理器中的硬件實現來執行浮點運算。這意味著就浮點運算而言，Python 的行為類似於許多流行的語言，包括 C 和 Java。許多可以輕鬆地用十進制表示的數字不能用二進制浮點表示。例如，在輸入以下語句後:

>>> x = 1.2

為 x 存儲的值是與十進制的值 1.2 (非常接近) 的近似值，但不完全等於它。在典型的機器上，實際存儲的值是：

1.0011001100110011001100110011001100110011001100110011 (binary)

它對應於十進制數值:

1.1999999999999999555910790149937383830547332763671875 (decimal)

典型的 53 位精度為 Python 浮點數提供了 15-16 位小數的精度。要獲得更完整的解釋，請參閱 Python 教程中的 浮點算術 一章。

while (line = readline(f)) { // do something with line}但在 Python 中被強制寫成這樣:

while True: line = f.readline() if not line: break ... # do something with line

不允許在 Python 表達式中賦值的原因是這些其他語言中常見的、很難發現的錯誤，是由這個結構引起的：

if (x = 0) { // error handling}else { // code that only works for nonzero x}

錯誤是一個簡單的錯字：x = 0 ，將 0 賦給變量 x ，而比較 x == 0 肯定是可以預期的。已經有許多替代方案提案。大多數是為了少打一些字的黑客方案，但使用任意或隱含的語法或關鍵詞，並不符合語言變更提案的簡單標準：它應該直觀地向尚未被介紹到這一概念的人類讀者提供正確的含義。一個有趣的現象是，大多數有經驗的 Python 程序員都認識到 while True 的習慣用法，也不太在意是否能在表達式構造中賦值; 只有新人表達了強烈的願望希望將其添加到語言中。有一種替代的拼寫方式看起來很有吸引力，但通常不如"while True"解決方案可靠：

line = f.readline()while line: ... # do something with line... line = f.readline()

問題在於，如果你改變主意（例如你想把它改成 sys.stdin.readline() ），如何知道下一行。你必須記住改變程序中的兩個地方 -- 第二次出現隱藏在循環的底部。最好的方法是使用迭代器，這樣能通過 for 語句來循環遍歷對象。例如 file objects 支持迭代器協議，因此可以簡單地寫成:

for line in f: ... # do something with line...

07 為什麼 Python 對某些功能（例如 list.index()）使用方法來實現，而其他功能（例如 len(List)）使用函數實現？

正如 Guido 所說：(a) 對於某些操作，前綴表示法比後綴更容易閱讀 -- 前綴（和中綴！）運算在數學中有著悠久的傳統，就像在視覺上幫助數學家思考問題的記法。比較一下我們將 x*(a+b) 這樣的公式改寫為 x*a+x*b 的容易程度，以及使用原始 OO 符號做相同事情的笨拙程度。”(b) 當讀到寫有 len(X)的代碼時，就知道它要求的是某件東西的長度。這告訴我們兩件事：結果是一個整數，參數是某種容器。相反，當閱讀 x.len()時，必須已經知道 x 是某種實現接口的容器，或者是從具有標準 len()的類繼承的容器。當沒有實現映射的類有 get()或 key()方法，或者不是文件的類有 write()方法時，我們偶爾會感到困惑。—https://mail.python.org/pipermail/python-3000/2006-November/004643.html”08. 為什麼 join()是一個字符串方法而不是列表或元組方法？從 Python 1.6 開始，字符串變得更像其他標準類型，當添加方法時，這些方法提供的功能與始終使用 String 模塊的函數時提供的功能相同。這些新方法中的大多數已被廣泛接受，但似乎讓一些程序員感到不舒服的一種方法是：

", ".join(['1', '2', '4', '8', '16']) 

結果如下:

"1, 2, 4, 8, 16"

反對這種用法有兩個常見的論點。第一條是這樣的：“使用字符串文本(String Constant)的方法看起來真的很難看”，答案是也許吧，但是字符串文本只是一個固定值。如果在綁定到字符串的名稱上允許使用這些方法，則沒有邏輯上的理由使其在文字上不可用。第二個異議通常是這樣的：“我實際上是在告訴序列使用字符串常量將其成員連接在一起”。遺憾的是並非如此。出於某種原因，把 split() 作為一個字符串方法似乎要容易得多，因為在這種情況下，很容易看到:

"1, 2, 4, 8, 16".split(", ")

是對字符串文本的指令，用於返回由給定分隔符分隔的子字符串（或在默認情況下，返回任意空格）。join() 是字符串方法，因為在使用該方法時，您告訴分隔符字符串去迭代一個字符串序列，並在相鄰元素之間插入自身。此方法的參數可以是任何遵循序列規則的對象，包括您自己定義的任何新的類。對於字節和字節數組對象也有類似的方法。09. 異常有多快？如果沒有引發異常，則 try/except 塊的效率極高。實際上捕獲異常是昂貴的。在 2.0 之前的 Python 版本中，通常使用這個習慣用法:

try: value = mydict[key]except KeyError: mydict[key] = getvalue(key) value = mydict[key]

只有當你期望 dict 在任何時候都有 key 時，這才有意義。如果不是這樣的話，你就是應該這樣編碼：

if key in mydict: value = mydict[key]else: value = mydict[key] = getvalue(key)

對於這種特定的情況，您還可以使用 value = dict.setdefault(key, getvalue(key))，但前提是調用 getvalue()足夠便宜，因為在所有情況下都會對其進行評估。10. 為什麼 Python 中沒有 switch 或 case 語句？你可以通過一系列 if... elif... elif... else.輕鬆完成這項工作。對於 switch 語句語法已經有了一些建議，但尚未就是否以及如何進行範圍測試達成共識。有關完整的詳細信息和當前狀態，請參閱 PEP 275 。對於需要從大量可能性中進行選擇的情況，可以創建一個字典，將 case 值映射到要調用的函數。例如：

def function_1(...): ...
functions = {'a': function_1, 'b': function_2, 'c': self.method_1, ...}
func = functions[value]func()

對於對象調用方法，可以通過使用 getattr() 內置檢索具有特定名稱的方法來進一步簡化：

def visit_a(self, ...): ......
def dispatch(self, value): method_name = 'visit_' + str(value) method = getattr(self, method_name) method()

建議對方法名使用前綴，例如本例中的 visit_ 。如果沒有這樣的前綴，如果值來自不受信任的源，攻擊者將能夠調用對象上的任何方法。

for file in very_long_list_of_files: f = open(file) c = f.read(1)

實際上，使用 CPython 的引用計數和析構函數方案， 每個新賦值的 f 都會關閉前一個文件。然而，對於傳統的 GC，這些文件對象只能以不同的時間間隔（可能很長的時間間隔）被收集（和關閉）。如果要編寫可用於任何 python 實現的代碼，則應顯式關閉該文件或使用 with 語句；無論內存管理方案如何，這都有效：

for file in very_long_list_of_files: with open(file) as f: c = f.read(1)

15. 為什麼 CPython 不使用更傳統的垃圾回收方案？

首先，這不是 C 標準特性，因此不能移植。(是的，我們知道 Boehm GC 庫。它包含了 大多數 常見平臺（但不是所有平臺）的彙編代碼，儘管它基本上是透明的，但也不是完全透明的; 要讓 Python 使用它，需要使用補丁。)當 Python 嵌入到其他應用程序中時，傳統的 GC 也成為一個問題。在獨立的 Python 中，可以用 GC 庫提供的版本替換標準的 malloc()和 free()，嵌入 Python 的應用程序可能希望用 它自己 替代 malloc()和 free()，而可能不需要 Python 的。現在，CPython 可以正確地實現 malloc()和 free()。16. CPython 退出時為什麼不釋放所有內存？當 Python 退出時，從全局命名空間或 Python 模塊引用的對象並不總是被釋放。如果存在循環引用，則可能發生這種情況 C 庫分配的某些內存也是不可能釋放的（例如像 Purify 這樣的工具會抱怨這些內容）。但是，Python 在退出時清理內存並嘗試銷燬每個對象。如果要強制 Python 在釋放時刪除某些內容，請使用 atexit 模塊運行一個函數，強制刪除這些內容。

• 哈希按其地址（對象 ID）列出。這不起作用，因為如果你構造一個具有相同值的新列表，它將無法找到；例如:mydict = {[1, 2]: '12'} print(mydict[[1, 2]]) 會引發一個 KeyError 異常，因為第二行中使用的 [1, 2] 的 id 與第一行中的 id 不同。換句話說，應該使用 == 來比較字典鍵，而不是使用 is 。
• 使用列表作為鍵時進行復制。這沒有用的，因為作為可變對象的列表可以包含對自身的引用，然後複製代碼將進入無限循環。
• 允許列表作為鍵，但告訴用戶不要修改它們。當你意外忘記或修改列表時，這將產生程序中的一類難以跟蹤的錯誤。它還使一個重要的字典不變量無效：d.keys() 中的每個值都可用作字典的鍵。
• 將列表用作字典鍵後，應標記為其只讀。問題是，它不僅僅是可以改變其值的頂級對象；你可以使用包含列表作為鍵的元組。將任何內容作為鍵關聯到字典中都需要將從那裡可到達的所有對象標記為只讀 —— 並且自引用對象可能會導致無限循環。

如果需要，可以使用以下方法來解決這個問題，但使用它需要你自擔風險：你可以將一個可變結構包裝在一個類實例中，該實例同時具有 __eq__() 和 __hash__() 方法。然後，你必須確保駐留在字典（或其他基於 hash 的結構）中的所有此類包裝器對象的哈希值在對象位於字典（或其他結構）中時保持固定。

class ListWrapper: def __init__(self, the_list): self.the_list = the_list
 def __eq__(self, other): return self.the_list == other.the_list
 def __hash__(self): l = self.the_list result = 98767 - len(l)*555 for i, el in enumerate(l): try: result = result + (hash(el) % 9999999) * 1001 + i except Exception: result = (result % 7777777) + i * 333 return result

注意，哈希計算由於列表的某些成員可能不可用以及算術溢出的可能性而變得複雜。此外，必須始終如此，如果 o1 == o2 （即 o1.__eq__(o2) is True ）則 hash(o1) == hash(o2)``（即``o1.__hash__() == o2.__hash__() ），無論對象是否在字典中。如果你不能滿足這些限制，字典和其他基於 hash 的結構將會出錯。對於 ListWrapper ，只要包裝器對象在字典中，包裝列表就不能更改以避免異常。除非你準備好認真考慮需求以及不正確地滿足這些需求的後果，否則不要這樣做。請留意。21. 為什麼 list.sort() 沒有返回排序列表？在性能很重要的情況下，僅僅為了排序而複製一份列表將是一種浪費。因此， list.sort() 對列表進行了適當的排序。為了提醒您這一事實，它不會返回已排序的列表。這樣，當您需要排序的副本，但也需要保留未排序的版本時，就不會意外地覆蓋列表。如果要返回新列表，請使用內置 sorted() 函數。此函數從提供的可迭代列表中創建新列表，對其進行排序並返回。例如，下面是如何迭代遍歷字典並按 keys 排序:

for key in sorted(mydict): ... # do whatever with mydict[key]...

22. 如何在 Python 中指定和實施接口規範？

由 C++和 Java 等語言提供的模塊接口規範描述了模塊的方法和函數的原型。許多人認為接口規範的編譯時強制執行有助於構建大型程序。Python 2.6 添加了一個 abc 模塊，允許定義抽象基類 (ABCs)。然後可以使用 isinstance() 和 issubclass() 來檢查實例或類是否實現了特定的 ABC。collections.abc 模塊定義了一組有用的 ABCs 例如 Iterable ， Container , 和 MutableMapping對於 Python，通過對組件進行適當的測試規程，可以獲得接口規範的許多好處。還有一個工具 PyChecker，可用於查找由於子類化引起的問題。一個好的模塊測試套件既可以提供迴歸測試，也可以作為模塊接口規範和一組示例。許多 Python 模塊可以作為腳本運行，以提供簡單的“自我測試”。即使是使用複雜外部接口的模塊，也常常可以使用外部接口的簡單“樁代碼（stub）”模擬進行隔離測試。可以使用 doctest 和 unittest 模塊或第三方測試框架來構造詳盡的測試套件，以運行模塊中的每一行代碼。適當的測試規程可以幫助在 Python 中構建大型的、複雜的應用程序以及接口規範。事實上，它可能會更好，因為接口規範不能測試程序的某些屬性。例如， append() 方法將向一些內部列表的末尾添加新元素；接口規範不能測試您的 append() 實現是否能夠正確執行此操作，但是在測試套件中檢查這個屬性是很簡單的。編寫測試套件非常有用，您可能希望設計代碼時著眼於使其易於測試。一種日益流行的技術是面向測試的開發，它要求在編寫任何實際代碼之前，首先編寫測試套件的各個部分。當然，Python 允許您草率行事，根本不編寫測試用例。

class label(Exception): pass # declare a label
try: ... if condition: raise label() # goto label ...except label: # where to goto pass...

但是不允許你跳到循環的中間，這通常被認為是濫用 goto。謹慎使用。24. 為什麼原始字符串（r-strings）不能以反斜槓結尾？更準確地說，它們不能以奇數個反斜槓結束：結尾處的不成對反斜槓會轉義結束引號字符，留下未結束的字符串。原始字符串的設計是為了方便想要執行自己的反斜槓轉義處理的處理器(主要是正則表達式引擎)創建輸入。此類處理器將不匹配的尾隨反斜槓視為錯誤，因此原始字符串不允許這樣做。反過來，允許通過使用引號字符轉義反斜槓轉義字符串。當 r-string 用於它們的預期目的時，這些規則工作的很好。如果您正在嘗試構建 Windows 路徑名，請注意所有 Windows 系統調用都使用正斜槓:

f = open("/mydir/file.txt") # works fine!

如果您正在嘗試為 DOS 命令構建路徑名，請嘗試以下示例

dir = r"\\this\\is\\my\\dos\\dir" "\\\\"dir = r"\\this\\is\\my\\dos\\dir\\ "[:-1]dir = "\\\\this\\\\is\\\\my\\\\dos\\\\dir\\\\"

25. 為什麼 Python 沒有屬性賦值的“with”語句？

Python 有一個 'with' 語句，它封裝了塊的執行，在塊的入口和出口調用代碼。有些語言的結構是這樣的:

with obj: a = 1 # equivalent to obj.a = 1 total = total + 1 # obj.total = obj.total + 1

在 Python 中，這樣的結構是不明確的。其他語言，如 ObjectPascal、Delphi 和 C++ 使用靜態類型，因此可以毫不含糊地知道分配給什麼成員。這是靜態類型的要點 -- 編譯器 總是 在編譯時知道每個變量的作用域。Python 使用動態類型。事先不可能知道在運行時引用哪個屬性。可以動態地在對象中添加或刪除成員屬性。這使得無法通過簡單的閱讀就知道引用的是什麼屬性：局部屬性、全局屬性還是成員屬性？例如，採用以下不完整的代碼段:

def foo(a): with a: print(x)

該代碼段假設 "a" 必須有一個名為 "x" 的成員屬性。然而，Python 中並沒有告訴解釋器這一點。假設 "a" 是整數，會發生什麼？如果有一個名為 "x" 的全局變量，它是否會在 with 塊中使用？如您所見，Python 的動態特性使得這樣的選擇更加困難。然而，Python 可以通過賦值輕鬆實現 "with" 和類似語言特性（減少代碼量）的主要好處。代替:

function(args).mydict[index][index].a = 21function(args).mydict[index][index].b = 42function(args).mydict[index][index].c = 63 

寫成這樣:

ref = function(args).mydict[index][index]ref.a = 21ref.b = 42ref.c = 63

這也具有提高執行速度的副作用，因為 Python 在運行時解析名稱綁定，而第二個版本只需要執行一次解析。26. 為什麼 if/while/def/class 語句需要冒號？冒號主要用於增強可讀性(ABC 語言實驗的結果之一)。考慮一下這個:

if a == b print(a)

與

if a == b: print(a)

注意第二種方法稍微容易一些。請進一步注意，在這個 FAQ 解答的示例中，冒號是如何設置的；這是英語中的標準用法。另一個次要原因是冒號使帶有語法突出顯示的編輯器更容易工作；他們可以尋找冒號來決定何時需要增加縮進，而不必對程序文本進行更精細的解析。27. 為什麼 Python 在列表和元組的末尾允許使用逗號？Python 允許您在列表，元組和字典的末尾添加一個尾隨逗號:

[1, 2, 3,]('a', 'b', 'c',)d = { "A": [1, 5], "B": [6, 7], # last trailing comma is optional but good style}

有幾個理由允許這樣做。如果列表，元組或字典的字面值分佈在多行中，則更容易添加更多元素，因為不必記住在上一行中添加逗號。這些行也可以重新排序，而不會產生語法錯誤。不小心省略逗號會導致難以診斷的錯誤。例如:

x = [ "fee", "fie" "foo", "fum"]

這個列表看起來有四個元素，但實際上包含三個 : "fee", "fiefoo" 和 "fum" 。總是加上逗號可以避免這個錯誤的來源。允許尾隨逗號也可以使編程代碼更容易生成。

閱讀更多 視學算法 的文章

關鍵字: Java Guido Python