《Python高階程式設計（第2版）》之語法最佳實踐

編寫高效語法的能力會隨著時間逐步提高。回頭看看寫的第一個程式，你可能就會同意這個觀點。正確的語法看起來賞心悅目，而錯誤的語法則令人煩惱。

除了實現的演算法與程式架構設計之外，還要特別注意的是，程式的寫法也會嚴重影響它未來的發展。許多程式被丟棄並從頭重寫，就是因為難懂的語法、不清晰的API或不合常理的標準。

不過Python在最近幾年裡發生了很大變化。因此，如果你被鄰居（一個愛嫉妒的人，來自本地Ruby開發者使用者組）綁架了一段時間，並且遠離新聞，那麼你可能會對Python的新特性感到吃驚。從最早版本到目前的3.5版，這門語言已經做了許多改進，變得更加清晰、更加整潔、也更容易編寫。Python基礎知識並沒有發生很大變化，但現在使用的工具更符合人們的使用習慣。

本章將介紹現在這門語言的語法中最重要的元素，以及它們的使用技巧，如下所示。

• 列表推導（list comprehension）。


• 迭代器（iterator）和生成器（generator）。


• 描述符（descriptor）和屬性（property）。


• 裝飾器（decorator）。


• with和contextlib。

速度提升或記憶體使用的程式碼效能技巧將會在第11、12章中講述。

2.1　Python的內建型別

Python提供了許多好用的資料型別，既包括數字型別，也包括集合型別。對於數字型別來說，語法並沒有什麼特別之處。當然，每種型別的定義會有些許差異，也有一些（可能）不太有名的運算子細節，但留給開發人員的選擇並不多。對於集合型別和字串來說，情況就發生變化了。雖然人們常說“做事的方法應該只有一種”，但留給Python開發人員的選擇確實有很多。在初學者看來，有些程式碼模式看起來既直觀又簡單，可是有經驗的程式設計師往往會認為它們不夠Pythonic，因為它們要麼效率低下，要麼就是過於囉嗦。

這種解決常見問題的Pythonic模式（許多程式設計師稱之為習語［idiom］）看起來往往只是美觀而已。但這種看法大錯特錯。大多數習語都揭示了Python的內部實現方式以及內建結構和模組的工作原理。想要深入理解這門語言，瞭解更多這樣的細節是很必要的。此外，社群本身也會受到關於Python工作原理的一些謠言和成見的影響。只有自己深入鑽研，你才能夠分辨出關於Python的流行說法的真假。

2.1.1　字串與位元組

對於只用Python 2程式設計的程式設計師來說，字串的話題可能會造成一些困惑。Python 3中只有一種能夠儲存文字資訊的資料型別，就是str（string，字串）。它是不可變的序列，儲存的是Unicode碼位（code point）。這是與Python 2的主要區別，Python 2用str表示位元組字串，這種型別現在在Python 3中用bytes物件來處理（但處理方式並不完全相同）。

Python中的字串是序列。基於這一事實，應該把字串放在其他容器型別的一節去介紹，但字串與其他容器型別在細節上有一個很重要的差異。字串可以儲存的資料型別有非常明確的限制，就是Unicode文字。

bytes以及可變的bytearray與str不同，只能用位元組作為序列值，即0 <= x < 256範圍內的整數。一開始可能會有點糊塗，因為其列印結果與字串非常相似：

>>> print(bytes([102, 111, 111]))
b'foo'複製程式碼

對於bytes和bytearray，在轉換為另一種序列型別（例如list或tuple）時可以顯示出其本來面目：

>>> list(b'foo bar')
[102, 111, 111, 32, 98, 97, 114]
>>> tuple(b'foo bar')
(102, 111, 111, 32, 98, 97, 114)複製程式碼

許多關於Python 3的爭議都是關於打破字串的向後相容和Unicode的處理方式。從Python 3.0開始，所有沒有字首的字串都是Unicode。因此，所有用單引號（'）、雙引號（"）或成組的3個引號（單引號或雙引號）包圍且沒有字首的值都表示str資料型別：

>>> type("some string")
< class 'str' >複製程式碼

在Python 2中，Unicode需要有u字首（例如u"some string"）。從Python 3.3開始，為保證向後相容，仍然可以使用這個字首，但它在Python 3中沒有任何語法上的意義。

前面的一些例子中已經提到過位元組，但為了保持前後一致，我們來明確介紹它的語法。位元組也被單引號、雙引號或三引號包圍，但必須有一個b或B字首：

>>> type(b"some bytes")
< class 'bytes' >複製程式碼

注意，Python語法中沒有bytearray字面值。

最後同樣重要的是，Unicode字串中包含無法用位元組表示的“抽象”文字。因此，如果Unicode字串沒有被編碼為二進位制資料的話，是無法儲存在磁碟中或通過網路傳送的。將字串物件編碼為位元組序列的方法有兩種：

• 利用str.encode(encoding, errors)方法，用註冊編解碼器（registered codec）對字串進行編碼。編解碼器由encoding引數指定，預設值為'utf-8'。第二個errors引數指定錯誤的處理方案，可以取'strict'（預設值）、'ignore'、'replace'、'xmlcharrefreplace'或其他任何註冊的處理程式（參見內建codecs模組的文件）。


• 利用bytes(source, encoding, errors)建構函式，建立一個新的位元組序列。如果source是str型別，那麼必須指定encoding引數，它沒有預設值。encoding和errors引數的用法與str.encode()方法中的相同。

用類似方法可以將bytes表示的二進位制資料轉換成字串：

• 利用bytes.decode(encoding, errors)方法，用註冊編解碼器對位元組進行解碼。這一方法的引數含義及其預設值與str.encode()相同。


• 利用str(source, encoding, error)建構函式，建立一個新的字串例項。與bytes()建構函式類似，如果source是位元組序列的話，必須指定str函式的encoding引數，它沒有預設值。

　

命名——位元組與位元組字串的對比　

由於Python 3中的變化，有些人傾向於將bytes例項稱為位元組字串。這主要是由於歷史原因——Python 3中的bytes是與Python 2中的str型別最為接近的序列型別（但並不完全相同）。不過bytes例項是位元組序列，也不需要表示文字資料。所以為了避免混淆，雖然bytes例項與字串具有相似性，但建議始終將其稱為bytes或位元組序列。Python 3中字串的概念是為文字資料準備的，現在始終是str型別。

1．實現細節

Python字串是不可變的。位元組序列也是如此。這一事實很重要，因為它既有優點又有缺點。它還會影響Python高效處理字串的方式。由於不變性，字串可以作為字典的鍵或set的元素，因為一旦初始化之後字串的值就不會改變。另一方面，每當需要修改過的字串時（即使只是微小的修改），都需要建立一個全新的字串例項。幸運的是，bytearray是bytes的可變版本，不存在這樣的問題。位元組陣列可以通過元素賦值來進行原處修改（無需建立新物件），其大小也可以像列表一樣動態地變化（利用append、pop、inseer等方法）。

2．字串拼接

由於Python字串是不可變的，在需要合併多個字串例項時可能會產生一些問題。如前所述，拼接任意不可變序列都會生成一個新的序列物件。思考下面這個例子，利用多個字串的重複拼接操作來建立一個新字串：

   s = ""
   for substring in substrings:
       s += substring複製程式碼

這會導致執行時間成本與字串總長度成二次函式關係。換句話說，這種方法效率極低。處理這種問題可以用str.join()方法。它接受可迭代的字串作為引數，返回合併後的字串。由於這是一個方法，實際的做法是利用空字串來呼叫它：

   s = "".join(substrings)複製程式碼

字串的這一方法還可以用於在需要合併的多個子字串之間插入分隔符，看下面這個例子：

>>> ','.join(['some', 'comma', 'separated', 'values'])
'some,comma,separated,values'複製程式碼

需要記住，僅僅因為join()方法速度更快（對於大型列表來說更是如此），並不意味著在所有需要拼接兩個字串的情況下都應該使用這一方法。雖然這是一種廣為認可的做法，但並不會提高程式碼的可讀性。可讀性是很重要的！在某些情況下，join()的效能可能還不如利用加法的普通拼接，下面舉幾個例子。

• 如果子字串的數量很少，而且已經包含在某個可迭代物件中，那麼在某些情況下，建立一個新序列來進行拼接操作的開銷可能會超過使用join()節省下來的開銷。


• 在拼接短的字面值時，由於CPython中的常數摺疊（constant folding），一些複雜的字面值（不只是字串）在編譯時會被轉換為更短的形式，例如'a' + 'b' + 'c'被轉換為'abc'。當然，這隻適用於相對短的常量（字面值）。

最後，如果事先知道字串的數目，可以用正確的字串格式化方法來保證字串拼接的最佳可讀性。字串格式化可以用str.format()方法或%運算子。如果程式碼段的效能不是很重要，或者優化字串拼接節省的開銷很小，那麼推薦使用字串格式化作為最佳方法。

　

常數摺疊和窺孔優化程式　

CPython對編譯過的原始碼使用窺孔優化程式來提高其效能。這種優化程式直接對Python位元組碼實現了許多常見的優化。如上所述，常數摺疊就是其功能之一。生成常數的長度不得超過一個固定值。在Python 3.5中這個固定值仍然是 20。不管怎樣，這個具體細節只是為了滿足讀者的好奇心而已，並不能在日常程式設計中使用。窺孔優化程式還實現了許多有趣的優化，詳細資訊請參見Python原始碼中的Python/peephole.c檔案。

2.1.2　集合型別

Python提供了許多內建的資料集合型別，如果選擇明智的話，可以高效解決許多問題。你可能已經學過下面這些集合型別，它們都有專門的字面值，如下所示。

• 列表（list）。


• 元組（tuple）。


• 字典（dictionary）。


• 集合（set）

Python的集合型別當然不止這4種，它的標準庫擴充套件了其可選列表。在許多情況下，問題的答案可能正如選擇正確的資料結構一樣簡單。本書的這一部分將深入介紹各種集合型別，以幫你做出更好的選擇。

1．列表與元組

Python最基本的兩個集合型別就是列表與元組，它們都表示物件序列。只要是花幾小時學過Python的人，應該都很容易發現二者之間的根本區別：列表是動態的，其大小可以改變；而元組是不可變的，一旦建立就不能修改。

雖然快速分配/釋放小型物件的優化方法有很多，但對於元素位置本身也是資訊的資料結構來說，推薦使用元組這一資料型別。舉個例子，想要儲存(x, y)座標對，元組可能是一個很好的選擇。反正關於元組的細節相當無趣。本章關於元組唯一重要的內容就是，tuple是不可變的（immutable），因此也是可雜湊的（hashable）。其具體含義將會在後面“字典”一節介紹。比元組更有趣的是另一種動態的資料結構list，以及它的工作原理和高效處理理方式。

（1）實現細節

許多程式設計師容易將Python的list型別與其他語言（如C、C++或Java）標準庫中常見的連結串列的概念相混淆。事實上，CPython的列表根本不是列表。在CPython中，列表被實現為長度可變的陣列。對於其他Python實現（如Jython和IronPython）而言，這種說法應該也是正確的，雖然這些專案的文件中沒有記錄其實現細節。造成這種混淆的原因很清楚。這種資料型別被命名為列表，還和連結串列實現有相似的介面。

為什麼這一點很重要，這又意味著什麼呢？列表是最常見的資料結構之一，其使用方式會對所有應用的效能帶來極大影響。此外，CPython又是最常見也最常用的Python實現，所以瞭解其內部實現細節至關重要。

從細節上來看，Python中的列表是由對其他物件的引用組成的的連續陣列。指向這個陣列的指標及其長度被儲存在一個列表頭結構中。這意味著，每次新增或刪除一個元素時，由引用組成的陣列需要改變大小（重新分配）。幸運的是，Python在建立這些陣列時採用了指數過分配（exponential over-allocation），所以並不是每次操作都需要改變陣列大小。這也是新增或取出元素的平攤複雜度較低的原因。不幸的是，在普通連結串列中“代價很小”的其他一些操作在Python中的計算複雜度卻相對較高：

• 利用list.insert方法在任意位置插入一個元素——複雜度為O(n)。


• 利用list.delete或del刪除一個元素——複雜度為O(n)。

這裡n是列表的長度。至少利用索引來查詢或修改元素的時間開銷與列表大小無關。表2-1是一張完整的表格，列出了大多數列表操作的平均時間複雜度。

表2-1

對於需要真正的連結串列（或者簡單來說，雙端append和pop操作的複雜度都是O(1)的資料結構）的場景，Python在內建的collections模組中提供了deque（雙端佇列）。它是棧和佇列的一般化，在需要用到雙向連結串列的地方都可以使用這種資料結構。

（2）列表推導

你可能知道，編寫這樣的程式碼是很痛苦的：

>>> evens = []
>>> for i in range(10):
...     if i % 2 == 0:
...         evens.append(i)
...
>>> evens
[0, 2, 4, 6, 8]複製程式碼

這種寫法可能適用於C語言，但在Python中的實際執行速度很慢，原因如下。

• 直譯器在每次迴圈中都需要判斷序列中的哪一部分需要修改。


• 需要用一個計數器來跟蹤需要處理的元素。


• 由於append()是一個列表方法，所以每次遍歷時還需要額外執行一個查詢函式。

列表推導正是解決這個問題的正確方法。它使用編排好的功能對上述語法的一部分做了自動化處理：

>>> [i for i in range(10) if i % 2 == 0]
[0, 2, 4, 6, 8]複製程式碼

這種寫法除了更加高效之外，也更加簡短，涉及的語法元素也更少。在大型程式中，這意味著更少的錯誤，程式碼也更容易閱讀和理解。

　

列表推導和內部陣列調整大小　

有些Python程式設計師中會謠傳這樣的說法：每新增幾個元素之後都要對錶示列表物件的內部陣列大小進行調整，這個問題可以用列表推導來解決。還有人說一次分配就可以將陣列大小調整到剛剛好。不幸的是，這些說法都是不正確的。

直譯器在對列表推導進行求值的過程中並不知道最終結果容器的大小，也就無法為它預先分配陣列的最終大小。因此，內部陣列的重新分配方式與for迴圈中完全相同。但在許多情況下，與普通迴圈相比，使用列表推導建立列表要更加整潔、更加快速。

（3）其他習語

Python習語的另一個典型例子是使用enumerate（列舉）。在迴圈中使用序列時，這個內建函式可以很方便地獲取其索引。以下面這段程式碼為例：

>>> i = 0
>>> for element in ['one', 'two', 'three']:
...     print(i, element)
...     i += 1
...
0 one
1 two
2 three複製程式碼

它可以替換為下面這段更短的程式碼：

>>> for i, element in enumerate(['one', 'two', 'three']):
...     print(i, element)
...
0 one
1 two
2 three複製程式碼

如果需要一個一個合併多個列表（或任意可迭代物件）中的元素，那麼可以使用內建的zip()函式。對兩個大小相等的可迭代物件進行均勻遍歷時，這是一種非常常用的模式：

>>> for item in zip([1, 2, 3], [4, 5, 6]):
...     print(item)
...
(1, 4)
(2, 5) 
(3, 6)複製程式碼

注意，對zip()函式返回的結果再次呼叫zip()，可以將其恢復原狀：

>>> for item in zip(zip([1, 2, 3], [4, 5, 6])):
...     print(item)
...
(1, 2, 3)
(4, 5, 6)複製程式碼

>>> first, second, third = "foo", "bar", 100
>>> first
'foo'
>>> second
'bar'
>>> third
100複製程式碼

>>> # 帶星號的表示式可以獲取序列的剩餘部分
>>> first, second, 複製程式碼rest = 0, 1, 2, 3
>>> first
0
>>> second
1
>>> rest
[2, 3]

>>> # 帶星號的表示式可以獲取序列的中間部分
>>> first, inner, last = 0, 1, 2, 3
>>> first
0
>>> inner
[1, 2]
>>> last
3

>>> # 巢狀解包
>>> (a, b), (c, d) = (1, 2), (3, 4)
>>> a, b, c, d
(1, 2, 3, 4)複製程式碼

   {
       1: ' one',
       2: ' two',
       3: ' three',
   }複製程式碼

   squares = {number: number**2 for number in range(100)}複製程式碼

>>> words = {'foo': 'bar', 'fizz': 'bazz'}
>>> items = words.items()
>>> words['spam'] = 'eggs'
>>> items
dictitems([('spam', 'eggs'), ('fizz', 'bazz'), ('foo', 'bar')])複製程式碼

>>> {number: None for number in range(5)}.keys()
dict_keys([0, 1, 2, 3, 4])複製程式碼

>>> {str(number): None for number in range(5)}.keys()
dict_keys(['1', '2', '4', '0', '3'])
>>> {str(number): None for number in reversed(range(5))}.keys()
dict_keys(['2', '3', '1', '4', '0'])複製程式碼

>>> from collections import OrderedDict
>>> OrderedDict((str(number), None) for number in range(5)).keys()
odictkeys(['0', '1', '2', '3', '4'])複製程式碼

>>> set([set([1,2,3]), set([2,3,4])])
Traceback (most recent call last):
  File "< stdin >", line 1, in < module >
TypeError: unhashable type: 'set'複製程式碼

>>> set([frozenset([1,2,3]), frozenset([2,3,4])])
{frozenset({1, 2, 3}), frozenset({2, 3, 4})}
>>> frozenset([frozenset([1,2,3]), frozenset([2,3,4])])
frozenset({frozenset({1, 2, 3}), frozenset({2, 3, 4})})複製程式碼

>>> i = iter('abc')
>>> next(i)
'a'
>>> next(i)
'b'
>>> next(i)
'c'
>>> next(i)
Traceback (most recent call last):
  File "< input >", line 1, in < module >
StopIteration複製程式碼

   class CountDown:
       def init(self, step):
           self.step = step
       def next(self):
           """Return the next element."""
           if self.step < = 0:
               raise StopIteration
           self.step -= 1
           return self.step
       def iter(self):
           """Return the iterator itself."""
           return self複製程式碼

>>> for element in CountDown(4):
...     print(element)
...
3
2 
1 
0複製程式碼

   def fibonacci():
       a, b = 0, 1
       while True:
           yield b
           a, b = b, a + b複製程式碼

>>> fib = fibonacci()
>>> next(fib)
1
>>> next(fib)
1
>>> next(fib)
2
>>> [next(fib) for i in range(10)]
[3, 5, 8, 13, 21, 34, 55, 89, 144, 233]複製程式碼

>>> import tokenize
>>> reader = open('hello.py').readline
>>> tokens = tokenize.generate_tokens(reader)
>>> next(tokens)
TokenInfo(type=57 (COMMENT), string='# -複製程式碼- coding: utf-8 --', start=(1,
0), end=(1, 23), line='# -- coding: utf-8 --\n')
>>> next(tokens)
TokenInfo(type=58 (NL), string='\n', start=(1, 23), end=(1, 24), line='#
-- coding: utf-8 --\n')
>>> next(tokens)
TokenInfo(type=1 (NAME), string='def', start=(2, 0), end=(2, 3),
line='def helloworld():\n')複製程式碼

   def power(values):
       for value in values:
           print('powering %s' % value)
           yield value
   def adder(values):
       for value in values:
           print('adding to %s' % value)
           if value % 2 == 0:
               yield value + 3
           else:
               yield value + 2複製程式碼

>>> elements = [1, 4, 7, 9, 12, 19]
>>> results = adder(power(elements))
>>> next(results)
powering 1
adding to 1
3
>>> next(results)
powering 4
adding to 4
7
>>> next(results)
powering 7
adding to 7
9複製程式碼

   def psychologist():
       print('Please tell me your problems')
       while True:
           answer = (yield)
           if answer is not None:
               if answer.endswith('?'):
                   print("Don't ask yourself too much questions")
               elif 'good' in answer:
                   print("Ahh that's good, go on")
               elif 'bad' in answer:
                   print("Don't be so negative")複製程式碼

>>> free = psychologist()
>>> next(free)
Please tell me your problems
>>> free.send('I feel bad')
Don't be so negative
>>> free.send("Why I shouldn't ?")
Don't ask yourself too much questions
>>> free.send("ok then i should find what is good for me")
Ahh that's good, go on複製程式碼

   class WithoutDecorators:
       def some_static_method():
           print("this is static method")
       some_static_method = staticmethod(some_static_method)
       def some_class_method(cls):
           print("this is class method")
       some_class_method = classmethod(some_class_method)複製程式碼

   class WithDecorators:
       @staticmethod
       def some_static_method():
           print("this is static method")

       @classmethod
       def some_class_method(cls):
           print("this is class method")複製程式碼

   @some_decorator
   def decorated_function():
       pass複製程式碼

   def decorated_function():
       pass
   decorated_function = some_decorator(decorated_function)複製程式碼

   def mydecorator(function):
       def wrapped(複製程式碼args, kwargs):
           # 在呼叫原始函式之前，做點什麼
           result = function(*args, kwargs)
           # 在函式呼叫之後，做點什麼，
           # 並返回結果
           return result
       # 返回wrapper作為裝飾函式
       return wrapped複製程式碼

（2）作為一個類

雖然裝飾器幾乎總是可以用函式實現，但在某些情況下，使用使用者自定義類可能更好。如果裝飾器需要複雜的引數化或者依賴於特定狀態，那麼這種說法往往是對的。

非引數化裝飾器用作類的通用模式如下：

   class DecoratorAsClass:
       def init(self, function):
           self.function = function

       def call(self, args, **kwargs):
           # 在呼叫原始函式之前，做點什麼
           result = self.function(args, kwargs)
           # 在呼叫函式之後，做點什麼，
           # 並返回結果
           return result複製程式碼

   def repeat(number=3):
       """多次重複執行裝飾函式。

       返回最後一次原始函式呼叫的值作為結果
       :param number: 重複次數，預設值是3
       """
       def actual_decorator(function):
           def wrapper(*args, 複製程式碼kwargs):
               result = None
               for _ in range(number):
                   result = function(args, **kwargs)
               return result
           return wrapper
       return actual_decorator複製程式碼

>>> @repeat(2)
... def foo():
...     print("foo")
...
>>> foo()
foo
foo複製程式碼

>>> @repeat()
... def bar():
...     print("bar")
...
>>> bar()
bar
bar
bar複製程式碼

>>> @repeat
... def bar():
...     pass
...
>>> bar()
Traceback (most recent call last):
  File "< input >", line 1, in < module >
TypeError: actual_decorator() missing 1 required positional
argument: 'function'複製程式碼

   def dummy_decorator(function):
       def wrapped(複製程式碼args, kwargs):
           """包裝函式內部文件。"""
           return function(*args, kwargs)
       return wrapped

   @dummy_decorator
   def function_with_importantdocstring():
       """這是我們想要儲存的重要文件字串。"""複製程式碼

如果我們在Python互動式會話中檢視function with important docstring()，會注意到它已經失去了原始名稱和文件字串：

>>> function_with_important_docstring.name
'wrapped'
>>> function_with_important_docstring.doc
'包裝函式內部文件。'複製程式碼

解決這個問題的正確方法，就是使用functools模組內建的wraps()裝飾器：

   from functools import wraps

   def preserving_decorator(function):
       @wraps(function)
       def wrapped(args, **kwargs):
           """包裝函式內部文件。"""
           return function(args, kwargs)
       return wrapped

   @preserving_decorator
   def function_with_important_docstring():
       """這是我們想要儲存的重要文件字串。"""複製程式碼

>>> function_with_important_docstring.name
'function_with_important_docstring.'
>>> function_with_important_docstring.doc
'這是我們想要儲存的重要文件字串。'複製程式碼

   rpcinfo = {}

   def xmlrpc(in=(), out=(type(None),)):
       def _xmlrpc(function):
           # 註冊簽名
           func_name = function.name
           rpc_info[funcname] = (in, out)
           def _check_types(elements, types):
               """用來檢查型別的子函式。"""
               if len(elements) != len(types):
                   raise TypeError('argument count is wrong')
               typed = enumerate(zip(elements, types))
               for index, couple in typed:
                   arg, of_the_right_type = couple
                   if isinstance(arg, of_the_right_type):
                       continue
                   raise TypeError(
                       'arg #%d should be %s' % (index,
                         of_the_right_type))

           # 包裝過的函式
           def xmlrpc(args):  # 沒有允許的關鍵詞
               # 檢查輸入的內容
               checkable_args = args[1:]  # 去掉self
               _check_types(checkableargs, in)
               # 執行函式
               res = function(args)
               # 檢查輸出的內容
               if not type(res) in (tuple, list):
                   checkable_res = (res,)
               else:
                   checkable_res = res
               _check_types(checkable_res, out)

               # 函式及其型別檢查成功
               return res
           return xmlrpc
       return xmlrpc複製程式碼

   class RPCView:
       @xmlrpc((int, int))  # two int -> None
       def meth1(self, int1, int2):
           print('received %d and %d' % (int1, int2))

       @xmlrpc((str,), (int,))  # string -> int
       def meth2(self, phrase):
           print('received %s' % phrase)
           return 12複製程式碼

>>> rpc_info
{'meth2': ((< class 'str'>,), (< class 'int'>,)), 'meth1': ((< class
'int'>, < class 'int'>), (,))}
>>> my = RPCView()
>>> my.meth1(1, 2)
received 1 and 2
>>> my.meth2(2)
Traceback (most recent call last):
  File "< input>", line 1, in < module>
  File "< input>", line 26, in xmlrpc
  File "< input>", line 20, in _check_types
TypeError: arg #0 should be < class 'str'>複製程式碼

   import time
   import hashlib
   import pickle

   cache = {}

   def is_obsolete(entry, duration):
       return time.time() - entry['time'] > duration

   def compute_key(function, args, kw):
       key = pickle.dumps((function.複製程式碼name, args, kw))
       return hashlib.sha1(key).hexdigest()

   def memoize(duration=10):
       def _memoize(function):
           def memoize(*args, 複製程式碼kw):
               key = compute_key(function, args, kw)

               # 是否已經擁有它了？
               if (key in cache and
                   not is_obsolete(cache[key], duration)):
                   print('we got a winner')
                   return cache[key]['value']
               # 計算
               result = function(args, **kw)
               # 儲存結果
               cache[key] = {
                   'value': result,
                   'time': time.time()
               }
               return result
           return memoize
       return _memoize複製程式碼

>>> @memoize()
... def very_very_very_complex_stuff(a, b):
...     # 如果在執行這個計算時計算機過熱
...     # 請考慮中止程式
...     return a + b
...
>>> very_very_very_complex_stuff(2, 2)
4
>>> very_very_very_complex_stuff(2, 2)
we got a winner
4
>>> @memoize(1) # 1秒後令快取失效
... def very_very_very_complex_stuff(a, b):
...     return a + b
...
>>> very_very_very_complex_stuff(2, 2)
4
>>> very_very_very_complex_stuff(2, 2)
we got a winner
4
>>> cache
{'c2727f43c6e39b3694649ee0883234cf': {'value': 4, 'time':
1199734132.7102251)}
>>> time.sleep(2)
>>> very_very_very_complex_stuff(2, 2)
4複製程式碼

   class User(object):
       def 複製程式碼init(self, roles):
           self.roles = roles

   class Unauthorized(Exception):
       pass

   def protect(role):
       def _protect(function):
           def protect(複製程式碼args, kw):
               user = globals().get('user')
               if user is None or role not in user.roles:
                   raise Unauthorized("I won't tell you")
               return function(*args, kw)
           return protect
       return _protect複製程式碼

>>> tarek = User(('admin', 'user'))
>>> bill = User(('user',))
>>> class MySecrets(object):
...     @protect('admin')
...     def waffle_recipe(self):
...         print('use tons of butter!')
...
>>> these_are = MySecrets()
>>> user = tarek
>>> these_are.waffle_recipe()
use tons of butter!
>>> user = bill
>>> these_are.waffle_recipe()
Traceback (most recent call last):
File "< stdin>", line 1, in < module>
File "< stdin>", line 7, in wrap
main.Unauthorized: I won't tell you複製程式碼

   from threading import RLock
   lock = RLock()

   def synchronized(function):
       def _synchronized(args, **kw):
           lock.acquire()
           try:
               return function(args, **kw)
           finally:
               lock.release()
           return _synchronized

   @synchronized
   def thread_safe():  # 確保鎖定資源
       pass複製程式碼

>>> hosts = open('/etc/hosts')
>>> try:
...     for line in hosts:
...         if line.startswith('#'):
...             continue
...         print(line.strip())
... finally:
...     hosts.close()
...
127.0.0.1       localhost
255.255.255.255 broadcasthost
::1             localhost複製程式碼

>>> with open('/etc/hosts') as hosts:
...     for line in hosts:
...         if line.startswith('#'):
...             continue
...         print(line.strip())
...
127.0.0.1       localhost
255.255.255.255 broadcasthost
::1             localhost複製程式碼

   with context_manager:
       # 程式碼塊
       ...複製程式碼

   with context_manager as context:
       # 程式碼塊
       ...複製程式碼

   with A() as a, B() as b:
       ...複製程式碼

   with A() as a:
       with B() as b:
           ...複製程式碼

• enter (self)：更多內容請訪問docs.python.org/3.3/referen… #object.enter。


• exit (self, exc type, exc value, traceback)：更多內容請訪問docs.python.org/3.3/referen….exit。

• 呼叫 enter 方法。任何返回值都會繫結到指定的as子句。


• 執行內部程式碼塊。


• 呼叫 exit 方法。

exit 接受程式碼塊中出現錯誤時填入的3個引數。如果沒有出現錯誤，那麼這3個引數都被設為None。出現錯誤時， exit 不應該重新引發這個錯誤，因為這是呼叫者（caller）的責任。但它可以通過返回True來避免引發異常。這可用於實現一些特殊的使用場景，例如下一節將會看到的contextmanager裝飾器。但在大多數使用場景中，這一方法的正確行為是執行類似於finally子句的一些清理工作，無論程式碼塊中發生了什麼，它都不會返回任何內容。

   class ContextIllustration:
       def 複製程式碼enter(self):
           print('entering context')
       def exit(self, exc_type, exc_value, traceback):
           print('leaving context')

           if exc_type is None:
               print('with no error')
           else:
               print('with an error (%s)' % exc_value)複製程式碼

>>> with ContextIllustration():
...     print("inside")
...
entering context
inside
leaving context
with no error複製程式碼

>>> with ContextIllustration():
...     raise RuntimeError("raised within 'with'")
...
entering context
leaving context
with an error (raised within 'with')
Traceback (most recent call last):
  File "< input >", line 2, in < module >
RuntimeError: raised within 'with'複製程式碼

使用類似乎是實現Python語言提供的任何協議最靈活的方法，但對許多使用場景來說可能樣板太多。標準庫中新增了contextlib模組，提供了與上下文管理器一起使用的輔助函式。它最有用的部分是contextmanager裝飾器。你可以在一個函式裡面同時提供 enter 和 exit 兩部分，中間用yield語句分開（注意，這樣函式就變成了生成器）。用這個裝飾器編寫前面的例子，其程式碼如下：

   from contextlib import contextmanager

   @contextmanager
   def contextillustration():
       print('entering context')

       try:
           yield
       except Exception as e:
           print('leaving context')
           print('with an error (%s)' % e)
           # 需要再次丟擲異常
           raise
       else:
           print('leaving context')
           print('with no error')複製程式碼

>>> for number in range(1):
...     break
... else:
...     print("no break")
...
>>>
>>> for number in range(1):
...     pass
... else:
...     print("break")
...
break複製程式碼

>>> def f(ham: str, eggs: str = 'eggs') -> str:
...     pass
...
>>> print(f.annotations)
{'return': < class 'str' >, 'eggs': < class 'str' >, 'ham': < class 'str' >}複製程式碼

定義好之後，註解可以通過函式物件的 annotations __屬性獲取，它是一個字典，在應用執行期間可以獲取。

任何表示式都可以用作註解，其位置靠近預設引數，這樣可以建立一些迷惑人的函式定義，如下所示：

>>> def square(number: 0< =3 and 1=0) - > (\
...     +9000): return number**2
>>> square(10)
100複製程式碼

不過，註解的這種用法只會讓人糊塗，沒有任何其他作用。即使不用註解，編寫出難以閱讀和理解的程式碼也是相對容易的。

2．可能的用法

雖然註解有很大的潛力，但並沒有被廣泛使用。一篇介紹Python 3新增功能的文章（參見docs.python.org/3/whatsnew/…PEP 3107列出以下可能的使用場景：

• 提供型別資訊。
  
  
  • 型別檢查。
  
  
  • 讓IDE顯示函式接受和返回的型別。
  
  
  • 函式過載/通用函式。
  
  
  • 與其他語言之間的橋樑。
  
  
  • 適配。
  
  
  • 謂詞邏輯函式。
  
  
  • 資料庫查詢對映。
  
  
  • RPC引數編組。
  
  
  
  


• 其他資訊。
  
  
  • 引數和返回值的文件。
  
  
  
  

雖然函式註解存在的時間和Python 3一樣長，但仍然很難找到任一常見且積極維護的包，將函式註解用作型別檢查之外的功能。所以函式註解仍主要用於試驗和玩耍，這也是Python 3最初發布時包含該功能的最初目的。

2.4　小結

本章介紹了不直接與Python類和麵向物件程式設計相關的多個最佳語法實踐。本章第一部分重點介紹了與Python序列和集合相關的語法特性，也討論了字串和位元組相關的序列。本章其餘部分介紹了兩組獨立的語法元素：一組是初學者相對難以理解的（例如迭代器、生成器和裝飾器），另一組是鮮為人知的（for...else子句和函式註解）。

                </div>複製程式碼