<kbd id="afajh"><form id="afajh"></form></kbd>
<strong id="afajh"><dl id="afajh"></dl></strong>
    <del id="afajh"><form id="afajh"></form></del>
        1. <th id="afajh"><progress id="afajh"></progress></th>
          <b id="afajh"><abbr id="afajh"></abbr></b>
          <th id="afajh"><progress id="afajh"></progress></th>

          27 個為什么,幫助你更好的理解Python

          共 13185字,需瀏覽 27分鐘

           ·

          2022-11-22 22:00

          選自《Python官方文檔》

          https://docs.python.org/zh-cn/3.7/faq/design.html
          目錄

          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.00.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 (非常接近) 的近似值,但不完全等于它。在典型的機(jī)器上,實際存儲的值是:
          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ū)嵗龑傩远皇蔷植孔兞俊i喿x self.x 或 self.meth() 可以清楚地表明,即使您不知道類的定義,也會使用實例變量或方法。在 C++ 中,可以通過缺少局部變量聲明來判斷(假設(shè)全局變量很少見或容易識別) —— 但是在 Python 中沒有局部變量聲明,所以必須查找類定義才能確定。一些 C++ 和 Java 編碼標(biāo)準(zhǔn)要求實例屬性具有 m_ 前綴,因此這種顯式性在這些語言中仍然有用。
          其次,這意味著如果要顯式引用或從特定類調(diào)用該方法,不需要特殊語法。在 C++ 中,如果你想使用在派生類中重寫基類中的方法,你必須使用 :: 運算符 -- 在 Python 中你可以編寫 baseclass.methodname(self, <argumentlist>)。這對于 __init__() 方法非常有用,特別是在派生類方法想要擴(kuò)展同名的基類方法,而必須以某種方式調(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 中被強(qiáng)制寫成這樣:
          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á)了強(qiáng)烈的愿望希望將其添加到語言中。
          有一種替代的拼寫方式看起來很有吸引力,但通常不如"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 堆棧幀。此外,擴(kuò)展可以隨時回調(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 編譯為機(jī)器代碼,C 或其他語言嗎?

          Cython 將帶有可選注釋的 Python 修改版本編譯到 C 擴(kuò)展中。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ù)來檢測不可訪問的對象,并使用另一種機(jī)制來收集引用循環(huán),定期執(zhí)行循環(huán)檢測算法來查找不可訪問的循環(huán)并刪除所涉及的對象。gc 模塊提供了執(zhí)行垃圾回收、獲取調(diào)試統(tǒng)計信息和優(yōu)化收集器參數(shù)的函數(shù)。
          但是,其他實現(xiàn)(如 Jython 或 PyPy ),)可以依賴不同的機(jī)制,如完全的垃圾回收器 。如果你的 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)

          15. 為什么 CPython 不使用更傳統(tǒng)的垃圾回收方案?

          首先,這不是 C 標(biāo)準(zhǔn)特性,因此不能移植。(是的,我們知道 Boehm GC 庫。它包含了 大多數(shù) 常見平臺(但不是所有平臺)的匯編代碼,盡管它基本上是透明的,但也不是完全透明的; 要讓 Python 使用它,需要使用補丁。)
          當(dāng) Python 嵌入到其他應(yīng)用程序中時,傳統(tǒng)的 GC 也成為一個問題。在獨立的 Python 中,可以用 GC 庫提供的版本替換標(biāo)準(zhǔn)的 malloc()和 free(),嵌入 Python 的應(yīng)用程序可能希望用 它自己 替代 malloc()和 free(),而可能不需要 Python 的。現(xiàn)在,CPython 可以正確地實現(xiàn) malloc()和 free()。

          16. CPython 退出時為什么不釋放所有內(nèi)存?

          當(dāng) Python 退出時,從全局命名空間或 Python 模塊引用的對象并不總是被釋放。如果存在循環(huán)引用,則可能發(fā)生這種情況 C 庫分配的某些內(nèi)存也是不可能釋放的(例如像 Purify 這樣的工具會抱怨這些內(nèi)容)。但是,Python 在退出時清理內(nèi)存并嘗試銷毀每個對象。
          如果要強(qiáng)制 Python 在釋放時刪除某些內(nèi)容,請使用 atexit 模塊運行一個函數(shù),強(qiáng)制刪除這些內(nèi)容。

          17. 為什么有單獨的元組和列表數(shù)據(jù)類型?

          雖然列表和元組在許多方面是相似的,但它們的使用方式通常是完全不同的。可以認(rèn)為元組類似于 Pascal 記錄或 C 結(jié)構(gòu);它們是相關(guān)數(shù)據(jù)的小集合,可以是不同類型的數(shù)據(jù),可以作為一個組進(jìn)行操作。例如,笛卡爾坐標(biāo)適當(dāng)?shù)乇硎緸閮蓚€或三個數(shù)字的元組。
          另一方面,列表更像其他語言中的數(shù)組。它們傾向于持有不同數(shù)量的對象,所有對象都具有相同的類型,并且逐個操作。例如, os.listdir('.') 返回表示當(dāng)前目錄中的文件的字符串列表。如果向目錄中添加了一兩個文件,對此輸出進(jìn)行操作的函數(shù)通常不會中斷。
          元組是不可變的,這意味著一旦創(chuàng)建了元組,就不能用新值替換它的任何元素。列表是可變的,這意味著您始終可以更改列表的元素。只有不變元素可以用作字典的 key,因此只能將元組和非列表用作 key。

          18. 列表如何在 CPython 中實現(xiàn)?

          CPython 的列表實際上是可變長度的數(shù)組,而不是 lisp 風(fēng)格的鏈表。該實現(xiàn)使用對其他對象的引用的連續(xù)數(shù)組,并在列表頭結(jié)構(gòu)中保留指向該數(shù)組和數(shù)組長度的指針。
          這使得索引列表 a[i] 的操作成本與列表的大小或索引的值無關(guān)。
          當(dāng)添加或插入項時,將調(diào)整引用數(shù)組的大小。并采用了一些巧妙的方法來提高重復(fù)添加項的性能; 當(dāng)數(shù)組必須增長時,會分配一些額外的空間,以便在接下來的幾次中不需要實際調(diào)整大小。

          19. 字典如何在 CPython 中實現(xiàn)?

          CPython 的字典實現(xiàn)為可調(diào)整大小的哈希表。與 B-樹相比,這在大多數(shù)情況下為查找(目前最常見的操作)提供了更好的性能,并且實現(xiàn)更簡單。
          字典的工作方式是使用 hash() 內(nèi)置函數(shù)計算字典中存儲的每個鍵的 hash 代碼。hash 代碼根據(jù)鍵和每個進(jìn)程的種子而變化很大;例如,"Python" 的 hash 值為-539294296,而"python"(一個按位不同的字符串)的 hash 值為 1142331976。然后,hash 代碼用于計算內(nèi)部數(shù)組中將存儲該值的位置。假設(shè)您存儲的鍵都具有不同的 hash 值,這意味著字典需要恒定的時間 -- O(1),用 Big-O 表示法 -- 來檢索一個鍵。

          20. 為什么字典 key 必須是不可變的?

          字典的哈希表實現(xiàn)使用從鍵值計算的哈希值來查找鍵。如果鍵是可變對象,則其值可能會發(fā)生變化,因此其哈希值也會發(fā)生變化。但是,由于無論誰更改鍵對象都無法判斷它是否被用作字典鍵值,因此無法在字典中修改條目。然后,當(dāng)你嘗試在字典中查找相同的對象時,將無法找到它,因為其哈希值不同。如果你嘗試查找舊值,也不會找到它,因為在該哈希表中找到的對象的值會有所不同。
          如果你想要一個用列表索引的字典,只需先將列表轉(zhuǎn)換為元組;用函數(shù) tuple(L) 創(chuàng)建一個元組,其條目與列表 L相同。元組是不可變的,因此可以用作字典鍵。
          已經(jīng)提出的一些不可接受的解決方案:
          • 哈希按其地址(對象 ID)列出。這不起作用,因為如果你構(gòu)造一個具有相同值的新列表,它將無法找到;例如:
            mydict = {[1, 2]: '12'}
            print(mydict[[1, 2]])

            會引發(fā)一個 KeyError 異常,因為第二行中使用的 [1, 2] 的 id 與第一行中的 id 不同。換句話說,應(yīng)該使用 == 來比較字典鍵,而不是使用 is
          • 使用列表作為鍵時進(jìn)行復(fù)制。這沒有用的,因為作為可變對象的列表可以包含對自身的引用,然后復(fù)制代碼將進(jìn)入無限循環(huán)。
          • 允許列表作為鍵,但告訴用戶不要修改它們。當(dāng)你意外忘記或修改列表時,這將產(chǎn)生程序中的一類難以跟蹤的錯誤。它還使一個重要的字典不變量無效:d.keys() 中的每個值都可用作字典的鍵。
          • 將列表用作字典鍵后,應(yīng)標(biāo)記為其只讀。問題是,它不僅僅是可以改變其值的頂級對象;你可以使用包含列表作為鍵的元組。將任何內(nèi)容作為鍵關(guān)聯(lián)到字典中都需要將從那里可到達(dá)的所有對象標(biāo)記為只讀 —— 并且自引用對象可能會導(dǎo)致無限循環(huán)。
          如果需要,可以使用以下方法來解決這個問題,但使用它需要你自擔(dān)風(fēng)險:你可以將一個可變結(jié)構(gòu)包裝在一個類實例中,該實例同時具有 __eq__() 和 __hash__() 方法。然后,你必須確保駐留在字典(或其他基于 hash 的結(jié)構(gòu))中的所有此類包裝器對象的哈希值在對象位于字典(或其他結(jié)構(gòu))中時保持固定。
          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
          注意,哈希計算由于列表的某些成員可能不可用以及算術(shù)溢出的可能性而變得復(fù)雜。
          此外,必須始終如此,如果 o1 == o2 (即 o1.__eq__(o2) is True )則 hash(o1) == hash(o2)``(即``o1.__hash__() == o2.__hash__() ),無論對象是否在字典中。如果你不能滿足這些限制,字典和其他基于 hash 的結(jié)構(gòu)將會出錯。
          對于 ListWrapper ,只要包裝器對象在字典中,包裝列表就不能更改以避免異常。除非你準(zhǔn)備好認(rèn)真考慮需求以及不正確地滿足這些需求的后果,否則不要這樣做。請留意。

          21. 為什么 list.sort() 沒有返回排序列表?

          在性能很重要的情況下,僅僅為了排序而復(fù)制一份列表將是一種浪費。因此, list.sort() 對列表進(jìn)行了適當(dāng)?shù)呐判颉榱颂嵝涯@一事實,它不會返回已排序的列表。這樣,當(dāng)您需要排序的副本,但也需要保留未排序的版本時,就不會意外地覆蓋列表。
          如果要返回新列表,請使用內(nèi)置 sorted() 函數(shù)。此函數(shù)從提供的可迭代列表中創(chuàng)建新列表,對其進(jìn)行排序并返回。例如,下面是如何迭代遍歷字典并按 keys 排序:
          for key in sorted(mydict):    ...  # do whatever with mydict[key]...

          22. 如何在 Python 中指定和實施接口規(guī)范?

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

          23. 為什么沒有 goto?

          可以使用異常捕獲來提供 “goto 結(jié)構(gòu)” ,甚至可以跨函數(shù)調(diào)用工作的 。許多人認(rèn)為異常捕獲可以方便地模擬 C,F(xiàn)ortran 和其他語言的 "go" 或 "goto" 結(jié)構(gòu)的所有合理用法。例如:
          class label(Exception): pass  # declare a label
          try: ... if condition: raise label() # goto label ...except label: # where to goto pass...
          但是不允許你跳到循環(huán)的中間,這通常被認(rèn)為是濫用 goto。謹(jǐn)慎使用。

          24. 為什么原始字符串(r-strings)不能以反斜杠結(jié)尾?

          更準(zhǔn)確地說,它們不能以奇數(shù)個反斜杠結(jié)束:結(jié)尾處的不成對反斜杠會轉(zhuǎn)義結(jié)束引號字符,留下未結(jié)束的字符串。
          原始字符串的設(shè)計是為了方便想要執(zhí)行自己的反斜杠轉(zhuǎn)義處理的處理器(主要是正則表達(dá)式引擎)創(chuàng)建輸入。此類處理器將不匹配的尾隨反斜杠視為錯誤,因此原始字符串不允許這樣做。反過來,允許通過使用引號字符轉(zhuǎn)義反斜杠轉(zhuǎn)義字符串。當(dāng) r-string 用于它們的預(yù)期目的時,這些規(guī)則工作的很好。
          如果您正在嘗試構(gòu)建 Windows 路徑名,請注意所有 Windows 系統(tǒng)調(diào)用都使用正斜杠:
          f = open("/mydir/file.txt")  # works fine!
          如果您正在嘗試為 DOS 命令構(gòu)建路徑名,請嘗試以下示例
          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' 語句,它封裝了塊的執(zhí)行,在塊的入口和出口調(diào)用代碼。有些語言的結(jié)構(gòu)是這樣的:
          with obj:    a = 1               # equivalent to obj.a = 1    total = total + 1   # obj.total = obj.total + 1
          在 Python 中,這樣的結(jié)構(gòu)是不明確的。
          其他語言,如 ObjectPascal、Delphi 和 C++ 使用靜態(tài)類型,因此可以毫不含糊地知道分配給什么成員。這是靜態(tài)類型的要點 -- 編譯器 總是 在編譯時知道每個變量的作用域。
          Python 使用動態(tài)類型。事先不可能知道在運行時引用哪個屬性。可以動態(tài)地在對象中添加或刪除成員屬性。這使得無法通過簡單的閱讀就知道引用的是什么屬性:局部屬性、全局屬性還是成員屬性?
          例如,采用以下不完整的代碼段:
          def foo(a):    with a:        print(x)
          該代碼段假設(shè) "a" 必須有一個名為 "x" 的成員屬性。然而,Python 中并沒有告訴解釋器這一點。假設(shè) "a" 是整數(shù),會發(fā)生什么?如果有一個名為 "x" 的全局變量,它是否會在 with 塊中使用?如您所見,Python 的動態(tài)特性使得這樣的選擇更加困難。
          然而,Python 可以通過賦值輕松實現(xiàn) "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
          這也具有提高執(zhí)行速度的副作用,因為 Python 在運行時解析名稱綁定,而第二個版本只需要執(zhí)行一次解析。

          26. 為什么 if/while/def/class 語句需要冒號?

          冒號主要用于增強(qiáng)可讀性(ABC 語言實驗的結(jié)果之一)。考慮一下這個:
          if a == b    print(a)
          if a == b:    print(a)
          注意第二種方法稍微容易一些。請進(jìn)一步注意,在這個 FAQ 解答的示例中,冒號是如何設(shè)置的;這是英語中的標(biāo)準(zhǔn)用法。
          另一個次要原因是冒號使帶有語法突出顯示的編輯器更容易工作;他們可以尋找冒號來決定何時需要增加縮進(jìn),而不必對程序文本進(jìn)行更精細(xì)的解析。

          27. 為什么 Python 在列表和元組的末尾允許使用逗號?

          Python 允許您在列表,元組和字典的末尾添加一個尾隨逗號:
          [1, 2, 3,]('a', 'b', 'c',)d = {    "A": [1, 5],    "B": [6, 7],  # last trailing comma is optional but good style}
          有幾個理由允許這樣做。
          如果列表,元組或字典的字面值分布在多行中,則更容易添加更多元素,因為不必記住在上一行中添加逗號。這些行也可以重新排序,而不會產(chǎn)生語法錯誤。
          不小心省略逗號會導(dǎo)致難以診斷的錯誤。例如:
          x = [  "fee",  "fie"  "foo",  "fum"]
          這個列表看起來有四個元素,但實際上包含三個 : "fee", "fiefoo" 和 "fum" 。總是加上逗號可以避免這個錯誤的來源。
          允許尾隨逗號也可以使編程代碼更容易生成。

          瀏覽 23
          點贊
          評論
          收藏
          分享

          手機(jī)掃一掃分享

          分享
          舉報
          評論
          圖片
          表情
          推薦
          點贊
          評論
          收藏
          分享

          手機(jī)掃一掃分享

          分享
          舉報
          <kbd id="afajh"><form id="afajh"></form></kbd>
          <strong id="afajh"><dl id="afajh"></dl></strong>
            <del id="afajh"><form id="afajh"></form></del>
                1. <th id="afajh"><progress id="afajh"></progress></th>
                  <b id="afajh"><abbr id="afajh"></abbr></b>
                  <th id="afajh"><progress id="afajh"></progress></th>
                  韩国少妇无码 | 男女超碰| 日本黄色电影免费 | ThePorn精品无码 | 五月天婷婷综合 |