Python是一種被廣泛使用的強(qiáng)大語(yǔ)言，讓我們深入這種語(yǔ)言，并且學(xué)習(xí)一些控制語(yǔ)句的技巧，標(biāo)準(zhǔn)庫(kù)的竅門和一些常見(jiàn)的陷阱。
Python（和它的各種庫(kù)）非常龐大。它被用于系統(tǒng)自動(dòng)化、web應(yīng)用、大數(shù)據(jù)、數(shù)據(jù)分析及安全軟件。這篇文件旨在展示一些知之甚少的技巧，這些技巧將帶領(lǐng)你走上一條開(kāi)發(fā)速度更快、調(diào)試更容易并且充滿趣味的道路。
學(xué)習(xí)Python和學(xué)習(xí)所有其他語(yǔ)言一樣，真正有用的資源不是各個(gè)語(yǔ)言繁瑣的超大官方文檔，而是使用常用語(yǔ)法、庫(kù)和Python社區(qū)共享知識(shí)的能力。
探索標(biāo)準(zhǔn)數(shù)據(jù)類型
謙遜的enumerate
遍歷在Python中非常簡(jiǎn)單，使用“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 |
但是同時(shí)使用元素的序號(hào)和元素本身也是常見(jiàn)的需求。我們經(jīng)常看到一些程序員使用len()和range()來(lái)通過(guò)下標(biāo)迭代列表，但是有一種更簡(jiǎn)單的方式。
|
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 函數(shù)可以同時(shí)遍歷元素及其序號(hào)。
Set類型
許多概念都可以歸結(jié)到對(duì)集合（set）的操作。例如：確認(rèn)一個(gè)列表沒(méi)有重復(fù)的元素；查看兩個(gè)列表共同的元素等等。Python提供了set數(shù)據(jù)類型以使類似這樣的操作更快捷更具可讀性。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
# deduplicate a list *fast*print(set(["ham", "eggs", "bacon", "ham"]))# {'bacon', 'eggs', 'ham'} # compare lists to find differences/similarities# {} without "key":"value" pairs makes a setmenu = {"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 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 函數(shù)比較列表中所有元素，返回兩個(gè)集合的交集。在我們的例子中，早餐的主食為bacon、eggs和ham。
collections.namedtuple
如果你不想給一個(gè)類添加方法，但又想使用foo.prop的調(diào)用方式，那么你需要的就是namedtuple。你提前定義好類屬性，然后就可以實(shí)例化一個(gè)輕量級(jí)的類，這樣的方式會(huì)比完整的對(duì)象占用更少的內(nèi)存。
|
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 |
用這種方式你無(wú)法設(shè)置namedtuple的屬性，正如你不能修改元組（tuple）中元素的值。你需要在實(shí)例化namedtuple的時(shí)候設(shè)置屬性的值。
|
1
2
3
4
5
|
LightObject = namedtuple('LightObject', ['shortname', 'otherprop'])n = LightObject(shortname='something', otherprop='something else')n.shortname # somethingcollections.defaultdict |
在寫Python應(yīng)用使用字典時(shí)，很多時(shí)候有些關(guān)鍵字一開(kāi)始并不存在，例如下面的例子。
|
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 我們可以跳過(guò)檢查關(guān)鍵字是否存在的邏輯，對(duì)某個(gè)未定義key的任意訪問(wèn)，都會(huì)返回一個(gè)空列表（或者其他數(shù)據(jù)類型）。
|
1
2
3
|
login_times = collections.defaultdict(list)for t in logins: login_times[t.username].append(t.datetime) |
你甚至可以使用自定義的類，這樣調(diào)用的時(shí)候?qū)嵗粋€(gè)類。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
from datetime import datetimeclass 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的特性，同時(shí)還想用訪問(wèn)屬性的方式來(lái)處理嵌套的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 Dictaddicted = Dict()addicted.a.b.c.d.e = 'really really nested'print(addicted)# {'a': {'b': {'c': {'d': {'e': 'really really nested'}}}}} |
這段小程序比標(biāo)準(zhǔn)的dict要容易寫的多。那么為什么不用defaultdict呢? 它看起來(lái)也夠簡(jiǎn)單了。
|
1
2
3
4
|
from collections import defaultdictdefault = defaultdict(dict)default['a']['b']['c']['d']['e'] = 'really really nested dict'# fails |
這段代碼看起來(lái)沒(méi)什么問(wèn)題，但是它最終拋出了KeyError異常。這是因?yàn)閐efault[‘a']是dict,不是defaultdict.讓我們構(gòu)造一個(gè)value是defaulted dictionaries類型的defaultdict,這樣也只能解決兩級(jí)嵌套。
如果你只是需要一個(gè)默認(rèn)計(jì)數(shù)器，你可以使用collection.Counter，這個(gè)類提供了許多方便的函數(shù)，例如 most_common.
控制流
當(dāng)學(xué)習(xí)Python中的控制結(jié)構(gòu)時(shí)，通常要認(rèn)真學(xué)習(xí) for, while,if-elif-else, 和 try-except。只要正確使用，這幾個(gè)控制結(jié)構(gòu)能夠處理絕大多數(shù)的情況。也是基于這個(gè)原因，幾乎你所遇到的所有語(yǔ)言都提供類似的控制結(jié)構(gòu)語(yǔ)句。在基本的控制結(jié)構(gòu)以外，Python也額外提供一些不常用的控制結(jié)構(gòu)，這些結(jié)構(gòu)會(huì)使你的代碼更具可讀性和可維護(hù)性。
Great Exceptations
Exceptions作為一種控制結(jié)構(gòu)，在處理數(shù)據(jù)庫(kù)、sockets、文件或者任何可能失敗的資源時(shí)非常常用。使用標(biāo)準(zhǔn)的 try 、except 結(jié)構(gòu)寫數(shù)據(jù)庫(kù)操作時(shí)通常是類型這樣的方式。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
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 exceptionexcept Exception: # log the failure db.rollback() db.close() |
你能發(fā)現(xiàn)這里的問(wèn)題嗎？這里有兩種可能的異常會(huì)觸發(fā)相同的except模塊。這意味著查找數(shù)據(jù)失敗（或者為查詢數(shù)據(jù)建立連接失敗）會(huì)引發(fā)回退操作。這絕對(duì)不是我們想要的，因?yàn)樵谶@個(gè)時(shí)間點(diǎn)上事務(wù)并沒(méi)有開(kāi)始。同樣回退也不應(yīng)該是數(shù)據(jù)庫(kù)連接失敗的正確響應(yīng)，因此讓我們將不同的情況分開(kāi)處理。
首先，我們將處理查詢數(shù)據(jù)。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
try: # get API data data = db.find(id='foo') # may raise exceptionexcept Exception: # log the failure and bail out log.warn("Could not retrieve FOO") return # manipulate the datadb.add(data) |
現(xiàn)在數(shù)據(jù)檢索擁有自己的try-except，這樣當(dāng)我們沒(méi)有取得數(shù)據(jù)時(shí)，我們可以采取任何處理方式。沒(méi)有數(shù)據(jù)我們的代碼不大可能再做有用的事，因此我們將僅僅退出函數(shù)。除了退出你也可以構(gòu)造一個(gè)默認(rèn)對(duì)象，重新進(jìn)行檢索或者結(jié)束整個(gè)程序。
現(xiàn)在讓我們將commit的代碼也單獨(dú)包起來(lái)，這樣它也能更優(yōu)雅的進(jìn)行錯(cuò)誤處理。
|
1
2
3
4
5
6
7
8
9
10
|
try: db.commit() # may raise exceptionexcept Exception: log.warn("Failure committing transaction, rolling back") db.rollback()else: log.info("Saved the new FOO")finally: db.close() |
實(shí)際上，我們已經(jīng)增加了兩端代碼。首先，讓我們看看else，當(dāng)沒(méi)有異常發(fā)生時(shí)會(huì)執(zhí)行這里的代碼。在我們的例子中，這里只是將事務(wù)成功的信息寫入日志，但是你可以按照需要進(jìn)行更多有趣的操作。一種可能的應(yīng)用是啟動(dòng)后臺(tái)任務(wù)或者通知。
很明顯finally 子句在這里的作用是保證db.close() 總是能夠運(yùn)行。回顧一下，我們可以看到所有和數(shù)據(jù)存儲(chǔ)相關(guān)的代碼最終都在相同的縮進(jìn)級(jí)別中形成了漂亮的邏輯分組。以后需要進(jìn)行代碼維護(hù)時(shí)，將很直觀的看出這幾行代碼都是用于完成 commit操作的。
Context and Control
之前，我們已經(jīng)看到使用異常來(lái)進(jìn)行處理控制流。通常，基本步驟如下：
- 嘗試獲取資源（文件、網(wǎng)絡(luò)連接等）
- 如果失敗，清除留下的所有東西
- 成功獲得資源則進(jìn)行相應(yīng)操作
- 寫日志
- 程序結(jié)束
考慮到這一點(diǎn)，讓我們?cè)倏匆幌律弦徽聰?shù)據(jù)庫(kù)的例子。我們使用try-except-finally來(lái)保證任何我們開(kāi)始的事務(wù)要么提交要么回退。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
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 |
我們前面的例子幾乎精確的映射到剛剛提到的步驟。這個(gè)邏輯變化的多嗎？并不多。
差不多每次存儲(chǔ)數(shù)據(jù)，我們都將做相同的步驟。我們可以將這些邏輯寫入一個(gè)方法中，或者我們可以使用上下文管理器（context manager）
|
1
2
3
4
5
6
7
8
9
10
|
db = db_library.connect("fakesql://")# as a functioncommit_or_rollback(db) # context managerwith transaction("fakesql://") as db: # retrieve data here # modify data here |
上下文管理器通過(guò)設(shè)置代碼段運(yùn)行時(shí)需要的資源（上下文環(huán)境）來(lái)保護(hù)代碼段。在我們的例子中，我們需要處理一個(gè)數(shù)據(jù)庫(kù)事務(wù)，那么過(guò)程將是這樣的：
- 連接數(shù)據(jù)庫(kù)
- 在代碼段的開(kāi)頭開(kāi)始操作
- 在代碼段的結(jié)尾提交或者回滾
- 在代碼段的結(jié)尾清除資源
讓我們建立一個(gè)上下文管理器，使用上下文管理器為我們隱藏?cái)?shù)據(jù)庫(kù)的設(shè)置工作。contextmanager 的接口非常簡(jiǎn)單。上下文管理器的對(duì)象需要具有一個(gè)__enter__()方法用來(lái)設(shè)置所需的上下文環(huán)境，還需要一個(gè)__exit__(exc_type, exc_val, exc_tb) 方法在離開(kāi)代碼段之后調(diào)用。如果沒(méi)有異常，那么三個(gè) exc_* 參數(shù)將都是None。
此處的__enter__方法非常簡(jiǎn)單，我們先從這個(gè)函數(shù)開(kāi)始。
|
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__方法只是返回?cái)?shù)據(jù)庫(kù)連接，在代碼段內(nèi)我們使用這個(gè)數(shù)據(jù)庫(kù)連接來(lái)存取數(shù)據(jù)。數(shù)據(jù)庫(kù)連接實(shí)際上是在__init__ 方法中建立的，因此如果數(shù)據(jù)庫(kù)建立連接失敗，那么代碼段將不會(huì)執(zhí)行。
現(xiàn)在讓我們定義事務(wù)將如何在 __exit__ 方法中完成。這里面要做的工作就比較多了，因?yàn)檫@里要處理代碼段中所有的異常并且還要完成事務(wù)的關(guān)閉工作。
|
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() |
現(xiàn)在我們就可以使用 DatabaseTransaction 類作為我們例子中的上下文管理器了。在類內(nèi)部， __enter__ 和 __exit__ 方法將開(kāi)始和設(shè)置數(shù)據(jù)連接并且處理善后工作。
|
1
2
3
4
5
6
|
# context managerwith DatabaseTransaction("fakesql://") as db: # retrieve data here # modify data here |
為了改進(jìn)我們的（簡(jiǎn)單）事務(wù)管理器，我們可以添加各種異常處理。即使是現(xiàn)在的樣子，這個(gè)事務(wù)管理器已經(jīng)為我們隱藏了許多復(fù)雜的處理，這樣你不用每次從數(shù)據(jù)庫(kù)拉取數(shù)據(jù)時(shí)都要擔(dān)心與數(shù)據(jù)庫(kù)相關(guān)的細(xì)節(jié)。
生成器
Python 2中引入的生成器（generators）是一種實(shí)現(xiàn)迭代的簡(jiǎn)單方式，這種方式不會(huì)一次產(chǎn)生所有的值。Python中典型的函數(shù)行為是開(kāi)始執(zhí)行，然后進(jìn)行一些操作，最后返回結(jié)果（或者不返回）。
生成器的行為卻不是這樣的。
|
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 關(guān)鍵字代替 return ，這就是生成器的獨(dú)特之處。當(dāng)我們調(diào)用 my_generator('thing') 時(shí)，我得到的不是函數(shù)的結(jié)果而是一個(gè)生成器對(duì)象，這個(gè)生成器對(duì)象可以在任何我們使用列表或其他可迭代對(duì)象的地方使用。
更常見(jiàn)的用法是像下面例子那樣將生成器作為循環(huán)的一部分。循環(huán)會(huì)一直進(jìn)行，直到生成器停止 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 |
生成器實(shí)例化之后不做任何事直到被要求產(chǎn)生數(shù)值，這時(shí)它將一直執(zhí)行到遇到第一個(gè) yield 并且將這個(gè)值返回給調(diào)用者，然后生成器保存上下文環(huán)境后掛起一直到調(diào)用者需要下一個(gè)值。
現(xiàn)在我們來(lái)寫一個(gè)比剛才返回三個(gè)硬編碼的值更有用的生成器。經(jīng)典的生成器例子是一個(gè)無(wú)窮的斐波納契數(shù)列生成器，我們來(lái)試一試。數(shù)列從1開(kāi)始，依次返回前兩個(gè)數(shù)之和。
|
1
2
3
4
5
6
|
def fib_generator(): a = 0 b = 1 while True: yield a a, b = b, a + b |
函數(shù)中的 while True 循環(huán)通常情況下應(yīng)該避免使用，因?yàn)檫@會(huì)導(dǎo)致函數(shù)無(wú)法返回，但是對(duì)于生成器卻無(wú)所謂，只要保證循環(huán)中有 yield 。我們?cè)谑褂眠@種生成器的時(shí)候要注意添加結(jié)束條件，因該生成器可以持續(xù)不斷的返回?cái)?shù)值。
現(xiàn)在，使用我們的生成器來(lái)計(jì)算第一個(gè)大于10000的斐波納契數(shù)列值。
|
1
2
3
4
5
|
min = 10000for number in fib_generator(): if number > min: print(number, "is the first fibonacci number over", min) break |
這非常簡(jiǎn)單，我們可以把數(shù)值定的任意大，代碼最終都會(huì)產(chǎn)生斐波納契數(shù)列中第一個(gè)大于X的值。
讓我們看一個(gè)更實(shí)際的例子。翻頁(yè)接口是應(yīng)對(duì)應(yīng)用限制和避免向移動(dòng)設(shè)備發(fā)送大于50兆JSON數(shù)據(jù)包的一種常見(jiàn)方法。首先，我們定義需要的API，然后我們?yōu)樗鼘懸粋€(gè)生成器在我們的代碼中隱藏翻頁(yè)邏輯。
我們使用的API來(lái)自Scream,這是一個(gè)用戶討論他們吃過(guò)的或想吃的餐廳的地方。他們的搜索API非常簡(jiǎn)單，基本是下面這樣。
|
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"} |
他們將下一頁(yè)的鏈接嵌入到API應(yīng)答中，這樣當(dāng)需要獲得下一頁(yè)時(shí)就非常簡(jiǎn)單了。我們能夠不考慮頁(yè)碼，只是獲取第一頁(yè)。為了獲得數(shù)據(jù)，我們將使用常見(jiàn)的 requests 庫(kù)，并且用生成器將其封裝以展示我們的搜索結(jié)果。
這個(gè)生成器將處理分頁(yè)并且限制重試邏輯，它將按照下述邏輯工作：
- 收到要搜索的內(nèi)容
- 查詢scream-about-food接口
- 如果接口失敗進(jìn)行重試
- 一次yield一個(gè)結(jié)果
- 如果有的話，獲取下一頁(yè)
- 當(dāng)沒(méi)有更多結(jié)果時(shí)，退出
非常簡(jiǎn)單。我來(lái)實(shí)現(xiàn)這個(gè)生成器，為了簡(jiǎn)化代碼我們暫時(shí)不考慮重試邏輯。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
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'] |
當(dāng)我們創(chuàng)建了生成器，你只需要傳入搜索的內(nèi)容，然后生成器將會(huì)生成請(qǐng)求，如果結(jié)果存在則獲取結(jié)果。當(dāng)然這里有些未處理的邊界問(wèn)題。異常沒(méi)有處理，當(dāng)API失敗或者返回了無(wú)法識(shí)別的JSON，生成器將拋出異常。
盡管存在這些未處理完善的地方，我們?nèi)匀荒苁褂眠@些代碼獲得我們的餐廳在關(guān)鍵字“coffee”搜索結(jié)果中的排序。
|
1
2
3
4
5
6
7
|
# pass a number to start at as the second argument if you don't want# zero-indexingfor number, result in enumerate(infinite_search("coffee"), 1): if result['name'] == "The Coffee Stain": print("Our restaurant, The Coffee Stain is number ", number) returnprint("Our restaurant, The Coffee Stain didnt't show up at all! :(") |
如果使用Python 3，當(dāng)你使用標(biāo)準(zhǔn)庫(kù)時(shí)你也能使用生成器。調(diào)用類似 dict.items() 這樣的函數(shù)時(shí)，不返回列表而是返回生成器。在Python 2中為了獲得這種行為，Python 2中添加了 dict.iteritems() 函數(shù)，但是用的比較少。
Python 2 and 3 compatibility
從Python 2 遷移到Python 3對(duì)任何代碼庫(kù)（或者開(kāi)發(fā)人員）都是一項(xiàng)艱巨的任務(wù)，但是寫出兩個(gè)版本都能運(yùn)行的代碼也是可能的。Python 2.7將被支持到2020年，但是許多新的特性將不支持向后兼容。目前，如果你還不能完全放棄Python 2, 那最好使用Python 2.7 和 3+兼容的特性。
對(duì)于兩個(gè)版本支持特性的全面指引，可以在python.org上看 Porting Python 2 Code 。
讓我們查看一下在打算寫兼容代碼時(shí)，你將遇到的最常見(jiàn)的情況，以及如何使用 __future__ 作為變通方案。
print or print()
幾乎每一個(gè)從Python 2 切換到Python 3的開(kāi)發(fā)者都會(huì)寫出錯(cuò)誤的print 表達(dá)式。幸運(yùn)的是，你能夠通過(guò)導(dǎo)入 print_function 模塊，將print作為一個(gè)函數(shù)而不是一個(gè)關(guān)鍵字來(lái)寫出可兼容的print.
|
1
2
3
4
5
6
|
for result in infinite_search("coffee"): if result['name'] == "The Coffee Stain": print("Our restaurant, The Coffee Stain is number ", result['number']) returnprint("Our restaurant, The Coffee Stain didn't show up at all! :(")Divided Over Division |
從Python 2 到 Python 3，除法的默認(rèn)行為也發(fā)生了變化。在Python 2中，整數(shù)的除法只進(jìn)行整除，小數(shù)部分全部截去。大多數(shù)用戶不希望這樣的行為，因此在Python 3中即使是整數(shù)之間的除法也執(zhí)行浮點(diǎn)除。
|
1
2
3
4
5
6
7
8
9
10
|
print "hello"# Python 2print("hello") # Python 3 from __future__ import print_functionprint("hello") # Python 2print("hello") # Python 3 |
這種行為的改變會(huì)導(dǎo)致編寫同時(shí)運(yùn)行在Python 2 和 Python 3上的代碼時(shí)，帶來(lái)一連串的小bug。我們?cè)僖淮涡枰?__future__ 模塊。導(dǎo)入 division 將使代碼在兩個(gè)版本中產(chǎn)生相同的運(yùn)行結(jié)果。
|
1
2
3
4
5
6
7
8
9
|
print(1 / 3) # Python 2# 0print(1 / 3) # Python 3# 0.3333333333333333print(1 // 3) # Python 3# 0 |
