Ryan 在 Red Hat的Openstack Heat專案組工作，已經用Python寫了許多大大小小的應用，包括web、編排計劃、後端應用等大小應用。
Python是一種被廣泛使用的強大語言，讓我們深入這種語言，並且學習一些控制語句的技巧，標準庫的竅門和一些常見的陷阱。
1 簡介
Python（和它的各種庫）非常龐大。它被用於系統自動化、web應用、大資料、資料分析及安全軟體。這篇檔案旨在展示一些知之甚少的技巧，這些技巧將帶領你走上一條開發速度更快、除錯更容易並且充滿趣味的道路。
學習Python和學習所有其他語言一樣，真正有用的資源不是各個語言繁瑣的超大官方文件，而是使用常用語法、庫和Python社群共享知識的能力。
探索標準資料型別
謙遜的enumerate
遍歷在Python中非常簡單，使用“for foo in bar:”就可以。
|
1 2 3 4 5 6 7 |
drinks = ["coffee", "tea", "milk", "water"] for drink in drinks: print("thirsty for", drink) #thirsty for coffee #thirsty for tea #thirsty for milk #thirsty for water |
但是同時使用元素的序號和元素本身也是常見的需求。我們經常看到一些程式設計師使用len()和range()來通過下標迭代列表，但是有一種更簡單的方式。
|
1 2 3 4 5 6 7 |
drinks = ["coffee", "tea", "milk", "water"] for index, drink in enumerate(drinks): print("Item {} is {}".format(index, drink)) #Item 0 is coffee #Item 1 is tea #Item 2 is milk #Item 3 is water |
enumerate 函式可以同時遍歷元素及其序號。
Set型別
許多概念都可以歸結到對集合（set）的操作。例如：確認一個列表沒有重複的元素；檢視兩個列表共同的元素等等。Python提供了set資料型別以使類似這樣的操作更快捷更具可讀性。
|
1 2 3 |
# deduplicate a list *fast* print(set(["ham", "eggs", "bacon", "ham"])) # {'bacon', 'eggs', 'ham'} |
|
1 2 3 4 5 6 7 8 9 10 11 12 |
# compare lists to find differences/similarities # {} without "key":"value" pairs makes a set menu = {"pancakes", "ham", "eggs", "bacon"} new_menu = {"coffee", "ham", "eggs", "bacon", "bagels"} new_items = new_menu.difference(menu) print("Try our new", ", ".join(new_items)) # Try our new bagels, coffee discontinued_items = menu.difference(new_menu) print("Sorry, we no longer have", ", ".join(discontinued_items)) # Sorry, we no longer have pancakes |
|
1 2 3 4 5 6 7 |
old_items = new_menu.intersection(menu) print("Or get the same old", ", ".join(old_items)) # Or get the same old eggs, bacon, ham full_menu = new_menu.union(menu) print("At one time or another, we've served:", ", ".join(full_menu)) # At one time or another, we've served: coffee, ham, pancakes, bagels, bacon, eggs |
intersection 函式比較列表中所有元素，返回兩個集合的交集。在我們的例子中，早餐的主食為bacon、eggs和ham。
collections.namedtuple
如果你不想給一個類新增方法，但又想使用foo.prop的呼叫方式，那麼你需要的就是namedtuple。你提前定義好類屬性，然後就可以例項化一個輕量級的類，這樣的方式會比完整的物件佔用更少的記憶體。
|
1 2 3 4 5 |
LightObject = namedtuple('LightObject', ['shortname', 'otherprop']) m = LightObject() m.shortname = 'athing' > Traceback (most recent call last): > AttributeError: can't set attribute |
用這種方式你無法設定namedtuple的屬性，正如你不能修改元組（tuple）中元素的值。你需要在例項化namedtuple的時候設定屬性的值。
|
1 2 3 |
LightObject = namedtuple('LightObject', ['shortname', 'otherprop']) n = LightObject(shortname='something', otherprop='something else') n.shortname # something |
collections.defaultdict
在寫Python應用使用字典時，很多時候有些關鍵字一開始並不存在，例如下面的例子。
|
1 2 3 4 5 6 |
login_times = {} for t in logins: if login_times.get(t.username, None): login_times[t.username].append(t.datetime) else: login_times[t.username] = [t.datetime] |
使用defaultdict 我們可以跳過檢查關鍵字是否存在的邏輯，對某個未定義key的任意訪問，都會返回一個空列表（或者其他資料型別）。
|
1 2 3 |
login_times = collections.defaultdict(list) for t in logins: login_times[t.username].append(t.datetime) |
你甚至可以使用自定義的類，這樣呼叫的時候例項化一個類。
|
1 2 3 4 5 6 7 8 9 10 11 12 |
from datetime import datetime class Event(object): def __init__(self, t=None): if t is None: self.time = datetime.now() else: self.time = t events = collections.defaultdict(Event) for e in user_events: print(events[e.name].time) |
如果既想具有defaultdict的特性，同時還想用訪問屬性的方式來處理巢狀的key，那麼可以瞭解一下 addict。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
normal_dict = { 'a': { 'b': { 'c': { 'd': { 'e': 'really really nested dict' } } } } } from addict import Dict addicted = Dict() addicted.a.b.c.d.e = 'really really nested' print(addicted) # {'a': {'b': {'c': {'d': {'e': 'really really nested'}}}}} |
這段小程式比標準的dict要容易寫的多。那麼為什麼不用defaultdict呢? 它看起來也夠簡單了。
|
1 2 3 |
from collections import defaultdict default = defaultdict(dict) default['a']['b']['c']['d']['e'] = 'really really nested dict' # fails |
這段程式碼看起來沒什麼問題，但是它最終丟擲了KeyError異常。這是因為default[‘a’]是dict,不是defaultdict.讓我們構造一個value是defaulted dictionaries型別的defaultdict,這樣也只能解決兩級巢狀。
如果你只是需要一個預設計數器，你可以使用collection.Counter，這個類提供了許多方便的函式，例如 most_common.
控制流
當學習Python中的控制結構時，通常要認真學習 for, while,if-elif-else, 和 try-except。只要正確使用，這幾個控制結構能夠處理絕大多數的情況。也是基於這個原因，幾乎你所遇到的所有語言都提供類似的控制結構語句。在基本的控制結構以外，Python也額外提供一些不常用的控制結構，這些結構會使你的程式碼更具可讀性和可維護性。
Great Exceptations
Exceptions作為一種控制結構，在處理資料庫、sockets、檔案或者任何可能失敗的資源時非常常用。使用標準的 try 、except 結構寫資料庫操作時通常是型別這樣的方式。
|
1 2 3 4 5 6 7 8 9 10 11 12 |
try: # get API data data = db.find(id='foo') # may raise exception # manipulate the data db.add(data) # save it again db.commit() # may raise exception except Exception: # log the failure db.rollback() db.close() |
你能發現這裡的問題嗎？這裡有兩種可能的異常會觸發相同的except模組。這意味著查詢資料失敗（或者為查詢資料建立連線失敗）會引發回退操作。這絕對不是我們想要的，因為在這個時間點上事務並沒有開始。同樣回退也不應該是資料庫連線失敗的正確響應，因此讓我們將不同的情況分開處理。
首先，我們將處理查詢資料。
|
1 2 3 4 5 6 7 8 9 10 |
try: # get API data data = db.find(id='foo') # may raise exception except Exception: # log the failure and bail out log.warn("Could not retrieve FOO") return # manipulate the data db.add(data) |
現在資料檢索擁有自己的try-except，這樣當我們沒有取得資料時，我們可以採取任何處理方式。沒有資料我們的程式碼不大可能再做有用的事，因此我們將僅僅退出函式。除了退出你也可以構造一個預設物件，重新進行檢索或者結束整個程式。
現在讓我們將commit的程式碼也單獨包起來，這樣它也能更優雅的進行錯誤處理。
|
1 2 3 4 5 6 7 8 9 |
try: db.commit() # may raise exception except Exception: log.warn("Failure committing transaction, rolling back") db.rollback() else: log.info("Saved the new FOO") finally: db.close() |
實際上，我們已經增加了兩端程式碼。首先，讓我們看看else，當沒有異常發生時會執行這裡的程式碼。在我們的例子中，這裡只是將事務成功的資訊寫入日誌，但是你可以按照需要進行更多有趣的操作。一種可能的應用是啟動後臺任務或者通知。
很明顯finally 子句在這裡的作用是保證db.close() 總是能夠執行。回顧一下，我們可以看到所有和資料儲存相關的程式碼最終都在相同的縮排級別中形成了漂亮的邏輯分組。以後需要進行程式碼維護時，將很直觀的看出這幾行程式碼都是用於完成 commit操作的。
Context and Control
之前，我們已經看到使用異常來進行處理控制流。通常，基本步驟如下：
- 嘗試獲取資源（檔案、網路連線等）
- 如果失敗，清除留下的所有東西
- 成功獲得資源則進行相應操作
- 寫日誌
- 程式結束
考慮到這一點，讓我們再看一下上一章資料庫的例子。我們使用try-except-finally來保證任何我們開始的事務要麼提交要麼回退。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
try: # attempt to acquire a resource db.commit() except Exception: # If it fails, clean up anything left behind log.warn("Failure committing transaction, rolling back") db.rollback() else: # If it works, perform actions # In this case, we just log success log.info("Saved the new FOO") finally: # Clean up db.close() # Program complete |
我們前面的例子幾乎精確的對映到剛剛提到的步驟。這個邏輯變化的多嗎？並不多。
差不多每次儲存資料，我們都將做相同的步驟。我們可以將這些邏輯寫入一個方法中，或者我們可以使用上下文管理器（context manager）
|
1 2 3 4 5 6 7 8 |
db = db_library.connect("fakesql://") # as a function commit_or_rollback(db) # context manager with transaction("fakesql://") as db: # retrieve data here # modify data here |
上下文管理器通過設定程式碼段執行時需要的資源（上下文環境）來保護程式碼段。在我們的例子中，我們需要處理一個資料庫事務，那麼過程將是這樣的：
- 連線資料庫
- 在程式碼段的開頭開始操作
- 在程式碼段的結尾提交或者回滾
- 在程式碼段的結尾清除資源
讓我們建立一個上下文管理器，使用上下文管理器為我們隱藏資料庫的設定工作。contextmanager 的介面非常簡單。上下文管理器的物件需要具有一個__enter__()方法用來設定所需的上下文環境，還需要一個__exit__(exc_type, exc_val, exc_tb) 方法在離開程式碼段之後呼叫。如果沒有異常，那麼三個 exc_* 引數將都是None。
此處的__enter__方法非常簡單，我們先從這個函式開始。
|
1 2 3 4 5 6 |
class DatabaseTransaction(object): def __init__(self, connection_info): self.conn = db_library.connect(connection_info) def __enter__(self): return self.conn |
__enter__方法只是返回資料庫連線，在程式碼段內我們使用這個資料庫連線來存取資料。資料庫連線實際上是在__init__ 方法中建立的，因此如果資料庫建立連線失敗，那麼程式碼段將不會執行。
現在讓我們定義事務將如何在 __exit__ 方法中完成。這裡面要做的工作就比較多了，因為這裡要處理程式碼段中所有的異常並且還要完成事務的關閉工作。
|
1 2 3 4 5 6 7 8 9 10 |
def __exit__(self, exc_type, exc_val, exc_tb): if exc_type is not None: self.conn.rollback() try: self.conn.commit() except Exception: self.conn.rollback() finally: self.conn.close() |
現在我們就可以使用 DatabaseTransaction 類作為我們例子中的上下文管理器了。在類內部， __enter__ 和 __exit__ 方法將開始和設定資料連線並且處理善後工作。
|
1 2 3 4 |
# context manager with DatabaseTransaction("fakesql://") as db: # retrieve data here # modify data here |
為了改進我們的（簡單）事務管理器，我們可以新增各種異常處理。即使是現在的樣子，這個事務管理器已經為我們隱藏了許多複雜的處理，這樣你不用每次從資料庫拉取資料時都要擔心與資料庫相關的細節。
生成器
Python 2中引入的生成器（generators）是一種實現迭代的簡單方式，這種方式不會一次產生所有的值。Python中典型的函式行為是開始執行，然後進行一些操作，最後返回結果（或者不返回）。
生成器的行為卻不是這樣的。
|
1 2 3 4 5 6 7 |
def my_generator(v): yield 'first ' + v yield 'second ' + v yield 'third ' + v print(my_generator('thing')) # <generator object my_generator at 0x....> |
使用 yield 關鍵字代替 return ，這就是生成器的獨特之處。當我們呼叫 my_generator('thing') 時，我得到的不是函式的結果而是一個生成器物件，這個生成器物件可以在任何我們使用列表或其他可迭代物件的地方使用。
更常見的用法是像下面例子那樣將生成器作為迴圈的一部分。迴圈會一直進行，直到生成器停止 yield值。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
for value in my_generator('thing'): print value # first thing # second thing # third thing gen = my_generator('thing') next(gen) # 'first thing' next(gen) # 'second thing' next(gen) # 'third thing' next(gen) # raises StopIteration exception |
生成器例項化之後不做任何事直到被要求產生數值，這時它將一直執行到遇到第一個 yield 並且將這個值返回給呼叫者，然後生成器儲存上下文環境後掛起一直到呼叫者需要下一個值。
現在我們來寫一個比剛才返回三個硬編碼的值更有用的生成器。經典的生成器例子是一個無窮的斐波納契數列生成器，我們來試一試。數列從1開始，依次返回前兩個數之和。
|
1 2 3 4 5 6 |
def fib_generator(): a = 0 b = 1 while True: yield a a, b = b, a + b |
函式中的 while True 迴圈通常情況下應該避免使用，因為這會導致函式無法返回，但是對於生成器卻無所謂，只要保證迴圈中有 yield 。我們在使用這種生成器的時候要注意新增結束條件，因該生成器可以持續不斷的返回數值。
現在，使用我們的生成器來計算第一個大於10000的斐波納契數列值。
|
1 2 3 4 5 |
min = 10000 for number in fib_generator(): if number > min: print(number, "is the first fibonacci number over", min) break |
這非常簡單，我們可以把數值定的任意大，程式碼最終都會產生斐波納契數列中第一個大於X的值。
讓我們看一個更實際的例子。翻頁介面是應對應用限制和避免向移動裝置傳送大於50兆JSON資料包的一種常見方法。首先，我們定義需要的API，然後我們為它寫一個生成器在我們的程式碼中隱藏翻頁邏輯。
我們使用的API來自Scream,這是一個使用者討論他們吃過的或想吃的餐廳的地方。他們的搜尋API非常簡單，基本是下面這樣。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
GET http://scream-about-food.com/search?q=coffee { "results": [ {"name": "Coffee Spot", "screams": 99 }, {"name": "Corner Coffee", "screams": 403 }, {"name": "Coffee Moose", "screams": 31 }, {...} ] "more": true, "_next": "http://scream-about-food.com/search?q=coffee?p=2" } |
他們將下一頁的連結嵌入到API應答中，這樣當需要獲得下一頁時就非常簡單了。我們能夠不考慮頁碼，只是獲取第一頁。為了獲得資料，我們將使用常見的 requests 庫，並且用生成器將其封裝以展示我們的搜尋結果。
這個生成器將處理分頁並且限制重試邏輯，它將按照下述邏輯工作：
- 收到要搜尋的內容
- 查詢scream-about-food介面
- 如果介面失敗進行重試
- 一次yield一個結果
- 如果有的話，獲取下一頁
- 當沒有更多結果時，退出
非常簡單。我來實現這個生成器，為了簡化程式碼我們暫時不考慮重試邏輯。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
import requests api_url = "http://scream-about-food.com/search?q={term}" def infinite_search(term): url = api_url.format(term) while True: data = requests.get(url).json() for place in data['results']: yield place # end if we've gone through all the results if not data['more']: break url = data['_next'] |
當我們建立了生成器，你只需要傳入搜尋的內容，然後生成器將會生成請求，如果結果存在則獲取結果。當然這裡有些未處理的邊界問題。異常沒有處理，當API失敗或者返回了無法識別的JSON，生成器將丟擲異常。
儘管存在這些未處理完善的地方，我們仍然能使用這些程式碼獲得我們的餐廳在關鍵字“coffee”搜尋結果中的排序。
|
1 2 3 4 5 6 7 |
# pass a number to start at as the second argument if you don't want # zero-indexing for number, result in enumerate(infinite_search("coffee"), 1): if result['name'] == "The Coffee Stain": print("Our restaurant, The Coffee Stain is number ", number) return print("Our restaurant, The Coffee Stain didnt't show up at all! :(") |
如果使用Python 3，當你使用標準庫時你也能使用生成器。呼叫類似 dict.items() 這樣的函式時，不返回列表而是返回生成器。在Python 2中為了獲得這種行為，Python 2中新增了 dict.iteritems() 函式，但是用的比較少。
Python 2 and 3 compatibility
從Python 2 遷移到Python 3對任何程式碼庫（或者開發人員）都是一項艱鉅的任務，但是寫出兩個版本都能執行的程式碼也是可能的。Python 2.7將被支援到2020年，但是許多新的特性將不支援向後相容。目前，如果你還不能完全放棄Python 2, 那最好使用Python 2.7 和 3+相容的特性。
對於兩個版本支援特性的全面指引，可以在python.org上看 Porting Python 2 Code 。
讓我們檢視一下在打算寫相容程式碼時，你將遇到的最常見的情況，以及如何使用 __future__ 作為變通方案。
print or print()
幾乎每一個從Python 2 切換到Python 3的開發者都會寫出錯誤的print 表示式。幸運的是，你能夠通過匯入 print_function 模組，將print作為一個函式而不是一個關鍵字來寫出可相容的print.
|
1 2 3 4 5 |
for result in infinite_search("coffee"): if result['name'] == "The Coffee Stain": print("Our restaurant, The Coffee Stain is number ", result['number']) return print("Our restaurant, The Coffee Stain didn't show up at all! :(") |
Divided Over Division
從Python 2 到 Python 3，除法的預設行為也發生了變化。在Python 2中，整數的除法只進行整除，小數部分全部截去。大多數使用者不希望這樣的行為，因此在Python 3中即使是整數之間的除法也執行浮點除。
|
1 2 3 4 5 6 |
print "hello" # Python 2 print("hello") # Python 3 from __future__ import print_function print("hello") # Python 2 print("hello") # Python 3 |
這種行為的改變會導致編寫同時執行在Python 2 和 Python 3上的程式碼時，帶來一連串的小bug。我們再一次需要 __future__ 模組。匯入 division 將使程式碼在兩個版本中產生相同的執行結果。
|
1 2 3 4 5 6 |
print(1 / 3) # Python 2 # 0 print(1 / 3) # Python 3 # 0.3333333333333333 print(1 // 3) # Python 3 # 0 |
最後-感謝閱讀
感謝閱讀，我希望你至少能學到了一點東西。假如你想要新增內容（或者糾正內容，沒有哪個作者是完美的）請留言，我會經常來看評論的。如果你喜歡這篇文章，你可能需要閱讀 list 和 dict comprehensions 或者關於 Python 2 和 3的更深刻的理解。
感謝 dalke (on HackerNews)、György Kiss、mikemikemikemikemike、Karl-Aksel Puulmann、Bartłomiej “furas” Burek 和 Peter Venable 等發現本文的錯誤和疏漏。