對于Python語言的14個疑問

這期內(nèi)容當(dāng)中小編將會給大家?guī)碛嘘P(guān)對于Python語言的14個疑問，文章內(nèi)容豐富且以專業(yè)的角度為大家分析和敘述，閱讀完這篇文章希望大家可以有所收獲。

01. 為什么使用縮進(jìn)來分組語句？

Guido van Rossum 認(rèn)為使用縮進(jìn)進(jìn)行分組非常優(yōu)雅，并且大大提高了普通 Python 程序的清晰度。大多數(shù)人在一段時間后就學(xué)會并喜歡上這個功能。

由于沒有開始/結(jié)束括號，因此解析器感知的分組與人類讀者之間不會存在分歧。偶爾 C 程序員會遇到像這樣的代碼片段：

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

如果條件為真，則只執(zhí)行 x++ 語句，但縮進(jìn)會使你認(rèn)為情況并非如此。即使是經(jīng)驗豐富的 C 程序員有時會長時間盯著它，想知道為什么即使 x > y ， y 也在減少。

因為沒有開始/結(jié)束括號，所以 Python 不太容易發(fā)生編碼式?jīng)_突。在 C 中，括號可以放到許多不同的位置。如果您習(xí)慣于閱讀和編寫使用一種風(fēng)格的代碼，那么在閱讀（或被要求編寫）另一種風(fēng)格時，您至少會感到有些不安。

許多編碼風(fēng)格將開始/結(jié)束括號單獨放在一行上。這使得程序相當(dāng)長，浪費了寶貴的屏幕空間，使得更難以對程序進(jìn)行全面的了解。理想情況下，函數(shù)應(yīng)該適合一個屏幕（例如，20--30 行）。20 行 Python 可以完成比 20 行 C 更多的工作。這不僅僅是由于缺少開始/結(jié)束括號 -- 缺少聲明和高級數(shù)據(jù)類型也是其中的原因 -- 但縮進(jìn)基于語法肯定有幫助。

02. 為什么簡單的算術(shù)運算得到奇怪的結(jié)果？

請看下一個問題。

03. 為什么浮點計算不準(zhǔn)確？

用戶經(jīng)常對這樣的結(jié)果感到驚訝：

>>> 1.2 - 1.0
0.19999999999999996

并且認(rèn)為這是 Python 中的一個 bug。其實不是這樣。這與 Python 關(guān)系不大，而與底層平臺如何處理浮點數(shù)字關(guān)系更大。

CPython 中的 float 類型使用 C 語言的 double 類型進(jìn)行存儲。float對象的值是以固定的精度（通常為 53 位）存儲的二進(jìn)制浮點數(shù)，由于 Python 使用 C 操作，而后者依賴于處理器中的硬件實現(xiàn)來執(zhí)行浮點運算。這意味著就浮點運算而言，Python 的行為類似于許多流行的語言，包括 C 和 Java。

許多可以輕松地用十進(jìn)制表示的數(shù)字不能用二進(jìn)制浮點表示。例如，在輸入以下語句后：

>>> x = 1.2

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

1.0011001100110011001100110011001100110011001100110011 (binary)

它對應(yīng)于十進(jìn)制數(shù)值：

1.1999999999999999555910790149937383830547332763671875 (decimal)

典型的 53 位精度為 Python 浮點數(shù)提供了 15-16 位小數(shù)的精度。

要獲得更完整的解釋，請參閱 Python 教程中的 浮點算術(shù) 一章。

04. 為什么 Python 字符串是不可變的？

有幾個優(yōu)點。

一個是性能：知道字符串是不可變的，意味著我們可以在創(chuàng)建時為它分配空間，并且存儲需求是固定不變的。這也是元組和列表之間區(qū)別的原因之一。

另一個優(yōu)點是，Python 中的字符串被視為與數(shù)字一樣“基本”。任何動作都不會將值 8 更改為其他值，在 Python 中，任何動作都不會將字符串 "8" 更改為其他值。

05. 為什么必須在方法定義和調(diào)用中顯式使用“self”？

這個想法借鑒了 Modula-3 語言。出于多種原因它被證明是非常有用的。

首先，更明顯的顯示出，使用的是方法或?qū)嵗龑傩远皇蔷植孔兞俊ｉ喿x self.x或 self.meth() 可以清楚地表明，即使您不知道類的定義，也會使用實例變量或方法。在 C++ 中，可以通過缺少局部變量聲明來判斷（假設(shè)全局變量很少見或容易識別） —— 但是在 Python 中沒有局部變量聲明，所以必須查找類定義才能確定。一些 C++ 和 Java 編碼標(biāo)準(zhǔn)要求實例屬性具有 m_ 前綴，因此這種顯式性在這些語言中仍然有用。

其次，這意味著如果要顯式引用或從特定類調(diào)用該方法，不需要特殊語法。在 C++ 中，如果你想使用在派生類中重寫基類中的方法，你必須使用 :: 運算符 -- 在 Python 中你可以編寫 baseclass.methodname(self, <argumentlist>)。這對于 __init__() 方法非常有用，特別是在派生類方法想要擴展同名的基類方法，而必須以某種方式調(diào)用基類方法時。

最后，它解決了變量賦值的語法問題：為了 Python 中的局部變量（根據(jù)定義！）在函數(shù)體中賦值的那些變量（并且沒有明確聲明為全局）賦值，就必須以某種方式告訴解釋器一個賦值是為了分配一個實例變量而不是一個局部變量，它最好是通過語法實現(xiàn)的（出于效率原因）。C++ 通過聲明來做到這一點，但是 Python 沒有聲明，僅僅為了這個目的而引入它們會很可惜。使用顯式的 self.var 很好地解決了這個問題。類似地，對于使用實例變量，必須編寫 self.var 意味著對方法內(nèi)部的非限定名稱的引用不必搜索實例的目錄。換句話說，局部變量和實例變量存在于兩個不同的命名空間中，您需要告訴 Python 使用哪個命名空間。

06. 為什么不能在表達(dá)式中賦值？

許多習(xí)慣于 C 或 Perl 的人抱怨，他們想要使用 C 的這個特性：

while (line = readline(f)) {
// do something with line
}

但在 Python 中被強制寫成這樣：

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

不允許在 Python 表達(dá)式中賦值的原因是這些其他語言中常見的、很難發(fā)現(xiàn)的錯誤，是由這個結(jié)構(gòu)引起的：

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

錯誤是一個簡單的錯字：x = 0 ，將 0 賦給變量 x ，而比較 x == 0 肯定是可以預(yù)期的。

已經(jīng)有許多替代方案提案。大多數(shù)是為了少打一些字的黑客方案，但使用任意或隱含的語法或關(guān)鍵詞，并不符合語言變更提案的簡單標(biāo)準(zhǔn)：它應(yīng)該直觀地向尚未被介紹到這一概念的人類讀者提供正確的含義。

一個有趣的現(xiàn)象是，大多數(shù)有經(jīng)驗的 Python 程序員都認(rèn)識到 while True 的習(xí)慣用法，也不太在意是否能在表達(dá)式構(gòu)造中賦值；只有新人表達(dá)了強烈的愿望希望將其添加到語言中。

有一種替代的拼寫方式看起來很有吸引力，但通常不如"while True"解決方案可靠：

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

問題在于，如果你改變主意（例如你想把它改成 sys.stdin.readline() ），如何知道下一行。你必須記住改變程序中的兩個地方 -- 第二次出現(xiàn)隱藏在循環(huán)的底部。

最好的方法是使用迭代器，這樣能通過 for 語句來循環(huán)遍歷對象。例如 file objects 支持迭代器協(xié)議，因此可以簡單地寫成：

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

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

正如 Guido 所說：

（a）對于某些操作，前綴表示法比后綴更容易閱讀 -- 前綴（和中綴?。┻\算在數(shù)學(xué)中有著悠久的傳統(tǒng)，就像在視覺上幫助數(shù)學(xué)家思考問題的記法。比較一下我們將 x*(a+b) 這樣的公式改寫為 x*a+x*b 的容易程度，以及使用原始 OO 符號做相同事情的笨拙程度。

（b）當(dāng)讀到寫有 len(X)的代碼時，就知道它要求的是某件東西的長度。這告訴我們兩件事：結(jié)果是一個整數(shù)，參數(shù)是某種容器。相反，當(dāng)閱讀 x.len()時，必須已經(jīng)知道 x 是某種實現(xiàn)接口的容器，或者是從具有標(biāo)準(zhǔn) len()的類繼承的容器。當(dāng)沒有實現(xiàn)映射的類有 get()或 key()方法，或者不是文件的類有 write()方法時，我們偶爾會感到困惑。

https://mail.python.org/pipermail/python-3000/2006-November/004643.html

08. 為什么 join()是一個字符串方法而不是列表或元組方法？

從 Python 1.6 開始，字符串變得更像其他標(biāo)準(zhǔn)類型，當(dāng)添加方法時，這些方法提供的功能與始終使用 String 模塊的函數(shù)時提供的功能相同。這些新方法中的大多數(shù)已被廣泛接受，但似乎讓一些程序員感到不舒服的一種方法是：

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

結(jié)果如下:

"1, 2, 4, 8, 16"

反對這種用法有兩個常見的論點。

第一條是這樣的：“使用字符串文本(String Constant)的方法看起來真的很難看”，答案是也許吧，但是字符串文本只是一個固定值。如果在綁定到字符串的名稱上允許使用這些方法，則沒有邏輯上的理由使其在文字上不可用。

第二個異議通常是這樣的：“我實際上是在告訴序列使用字符串常量將其成員連接在一起”。遺憾的是并非如此。出于某種原因，把 split() 作為一個字符串方法似乎要容易得多，因為在這種情況下，很容易看到：

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

是對字符串文本的指令，用于返回由給定分隔符分隔的子字符串（或在默認(rèn)情況下，返回任意空格）。

join() 是字符串方法，因為在使用該方法時，您告訴分隔符字符串去迭代一個字符串序列，并在相鄰元素之間插入自身。此方法的參數(shù)可以是任何遵循序列規(guī)則的對象，包括您自己定義的任何新的類。對于字節(jié)和字節(jié)數(shù)組對象也有類似的方法。

09. 異常有多快？

如果沒有引發(fā)異常，則 try/except 塊的效率極高。實際上捕獲異常是昂貴的。在 2.0 之前的 Python 版本中，通常使用這個習(xí)慣用法：

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

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

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

對于這種特定的情況，您還可以使用 value = dict.setdefault(key, getvalue(key))，但前提是調(diào)用 getvalue()足夠便宜，因為在所有情況下都會對其進(jìn)行評估。

10. 為什么 Python 中沒有 switch 或 case 語句？

你可以通過一系列 if... elif... elif... else.輕松完成這項工作。對于 switch 語句語法已經(jīng)有了一些建議，但尚未就是否以及如何進(jìn)行范圍測試達(dá)成共識。有關(guān)完整的詳細(xì)信息和當(dāng)前狀態(tài)，請參閱 PEP 275 。

對于需要從大量可能性中進(jìn)行選擇的情況，可以創(chuàng)建一個字典，將 case 值映射到要調(diào)用的函數(shù)。例如：

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

對于對象調(diào)用方法，可以通過使用 getattr() 內(nèi)置檢索具有特定名稱的方法來進(jìn)一步簡化：

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

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

11. 難道不能在解釋器中模擬線程，而非得依賴特定于操作系統(tǒng)的線程實現(xiàn)嗎？

答案 1：不幸的是，解釋器為每個 Python 堆棧幀推送至少一個 C 堆棧幀。此外，擴展可以隨時回調(diào) Python。因此，一個完整的線程實現(xiàn)需要對 C 的線程支持。

答案 2：幸運的是， Stackless Python 有一個完全重新設(shè)計的解釋器循環(huán)，可以避免 C 堆棧。

12. 為什么 lambda 表達(dá)式不包含語句？

Python 的 lambda 表達(dá)式不能包含語句，因為 Python 的語法框架不能處理嵌套在表達(dá)式內(nèi)部的語句。然而，在 Python 中，這并不是一個嚴(yán)重的問題。與其他語言中添加功能的 lambda 表單不同，Python 的 lambdas 只是一種速記符號，如果您懶得定義函數(shù)的話。

函數(shù)已經(jīng)是 Python 中的第一類對象，可以在本地范圍內(nèi)聲明。因此，使用 lambda 而不是本地定義的函數(shù)的唯一優(yōu)點是你不需要為函數(shù)創(chuàng)建一個名稱 -- 這只是一個分配了函數(shù)對象(與 lambda 表達(dá)式生成的對象類型完全相同)的局部變量！

13. 可以將 Python 編譯為機器代碼，C 或其他語言嗎？

Cython 將帶有可選注釋的 Python 修改版本編譯到 C 擴展中。Nuitka 是一個將 Python 編譯成 C++ 代碼的新興編譯器，旨在支持完整的 Python 語言。要編譯成 Java，可以考慮 VOC 。

14. Python 如何管理內(nèi)存？

Python 內(nèi)存管理的細(xì)節(jié)取決于實現(xiàn)。Python 的標(biāo)準(zhǔn)實現(xiàn) CPython 使用引用計數(shù)來檢測不可訪問的對象，并使用另一種機制來收集引用循環(huán)，定期執(zhí)行循環(huán)檢測算法來查找不可訪問的循環(huán)并刪除所涉及的對象。gc 模塊提供了執(zhí)行垃圾回收、獲取調(diào)試統(tǒng)計信息和優(yōu)化收集器參數(shù)的函數(shù)。

但是，其他實現(xiàn)(如 Jython 或 PyPy )，)可以依賴不同的機制，如完全的垃圾回收器 。如果你的 Python 代碼依賴于引用計數(shù)實現(xiàn)的行為，則這種差異可能會導(dǎo)致一些微妙的移植問題。

在一些 Python 實現(xiàn)中，以下代碼（在 CPython 中工作的很好）可能會耗盡文件描述符：

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

實際上，使用 CPython 的引用計數(shù)和析構(gòu)函數(shù)方案， 每個新賦值的 f 都會關(guān)閉前一個文件。然而，對于傳統(tǒng)的 GC，這些文件對象只能以不同的時間間隔（可能很長的時間間隔）被收集（和關(guān)閉）。

如果要編寫可用于任何 python 實現(xiàn)的代碼，則應(yīng)顯式關(guān)閉該文件或使用 with語句；無論內(nèi)存管理方案如何，這都有效：

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

上述就是小編為大家分享的對于Python語言的14個疑問了，如果剛好有類似的疑惑，不妨參照上述分析進(jìn)行理解。如果想知道更多相關(guān)知識，歡迎關(guān)注億速云行業(yè)資訊頻道。