弄懂這56個Python使用技巧，掌握Python高效開發

1. 枚舉 - enumerate 可以有參數哦

之前我們這樣操作：

i = 0for item in iterable:
print i, item i += 1

現在我們這樣操作：

for i, item in enumerate(iterable):

 print i, item

enumerate函數還可以接收第二個參數。就像下面這樣：

>>> list(enumerate('abc'))
[(0, 'a'), (1, 'b'), (2, 'c')] 
>>> list(enumerate('abc', 1)) 
[(1, 'a'), (2, 'b'), (3, 'c')]

如果你依然在編程的世界裏迷茫，可以加入我們的Python學習扣qun：784758214，看看前輩們是如何學習的。交流經驗。從基礎的python腳本到web開發、爬蟲、django、數據挖掘等，零基礎到項目實戰的資料都有整理。送給每一位python的小夥伴！分享一些學習的方法和需要注意的小細節，點擊加入我們的 python學習者聚集地

2. 字典/集合 解析

你也許知道如何進行列表解析，但是可能不知道字典/集合解析。它們簡單易用且高效。就像下面這個例子：

my_dict = {i: i * i for i in xrange(100)} 
my_set = {i * 15 for i in xrange(100)}
# There is only a difference of ':' in both
# 兩者的區別在於字典推導中有冒號

3. 強制浮點除法

from __future__ import division 
result = 1/2# print(result)# 0.5

4. 對Python表達式求值

我們都知道eval函數，但是我們知道literal_eval函數麼？也許很多人都不知道吧。可以用這種操作：

import ast 
my_list = ast.literal_eval(expr)

來代替以下這種操作：

expr = "[1, 2, 3]"my_list = eval(expr)

我相信對於大多數人來說這種形式是第一次看見，但是實際上這個在Python中已經存在很長時間了。

5. 字符串/數列 逆序

你可以用以下方法快速逆序排列數列：

>>> a = [1,2,3,4]>>> a[::-1]
[4, 3, 2, 1]# This creates a new reversed list. # If you want to reverse a list in place you can do:a.reverse()

這總方式也同樣適用於字符串的逆序：

>>> foo = "yasoob">>> foo[::-1]'boosay'

6. 三元運算

三元運算是if-else 語句的快捷操作，也被稱爲條件運算。這裏有幾個例子可以供你參考，它們可以讓你的代碼更加緊湊，更加美觀。

[on_true] if [expression] else [on_false]
x, y = 50, 25small = x if x < y else y

7. Python裏面如何拷貝一個對象

標準庫中的copy模塊提供了兩個方法來實現拷貝.一個方法是copy,它返回和參數包含內容一樣的對象.

import copynew_list = copy.copy(existing_list)

有些時候,你希望對象中的屬性也被複制,可以使用deepcopy方法:

import copynew_list_of_dicts = copy.deepcopy(existing_list_of_dicts)copy(x)Shallow copy operation on arbitrary Python objects.deepcopy(x, memo=None, _nil=[])
Deep copy operation on arbitrary Python objects.

8. python中如何判斷對象相等

首先是C#中字符串的==和equal方法。“==” :
對於內置值類型而言， == 判斷兩個內存值是否相等。
對於用戶自定義的值類型而言(Struct)， == 需要重載，否則不能使用。
對於引用類型而言，默認是同一引用才返回true，但是系統重載了很多引用類型的 == （比如下文提到的string），所以c#中引用類型的比較並不建議使用 ==。“equals” :
對於值類型而言， 內存相等才返回true。
對於引用類型而言，指向同一個引用纔算相等。
但是比較特殊的是字符串String,是一個特殊的引用型類型，在C#語言中，重載了string的equals()方法，使string對象用起來就像是值類型一樣。python中的 ==
python中的對象包含三要素:id, type, valueid 用來標識唯一一個對象，type標識對象的類型，value用來設置對象的值。is 判斷是否是一個對象，使用id來判斷的。
== 是判斷a對象的值是否是b對象的值，默認調用它的__eq__方法。

9. 命名技巧

今天閱讀代碼，發現一個不錯的函數命名方式:

def request(_argv):

就是把所有的參數前面都加上_下劃線，這樣你在函數體中，一眼就可以看出那些是局部變量，那些是作爲參數傳入的，類似把全局變量前面加上g。

10. 開發者工具集錦

• pydoc： 模塊可以根據源代碼中的docstrings爲任何可導入模塊生成格式良好的文檔。

• doctest模塊：該模塊可以從源代碼或獨立文件的例子中抽取出測試用例。

• unittest模塊：該模塊是一個全功能的自動化測試框架，該框架提供了對測試準備(test fixtures), 預定義測試集(predefined test suite)以及測試發現(test discovery)的支持。

• trace：模塊可以監控Python執行程序的方式，同時生成一個報表來顯示程序的每一行執行的次數。這些信息可以用來發現未被自動化測試集所覆蓋的程序執行路徑，也可以用來研究程序調用圖，進而發現模塊之間的依賴關係。編寫並執行測試可以發現絕大多數程序中的問題，Python使得debug工作變得更加簡單，這是因爲在大部分情況下，Python都能夠將未被處理的錯誤打印到控制檯中，我們稱這些錯誤信息爲traceback。如果程序不是在文本控制檯中運行的，traceback也能夠將錯誤信息輸出到日誌文件或是消息對話框中。當標準的traceback無法提供足夠的信息時，可以使用cgitb 模塊來查看各級棧和源代碼上下文中的詳細信息，比如局部變量。cgitb模塊還能夠將這些跟蹤信息以HTML的形式輸出，用來報告web應用中的錯誤。

• pdb：該模塊可以顯示出程序在錯誤產生時的執行路徑，同時可以動態地調整對象和代碼進行調試。

• profile, timeit: 開發者可以使用profile以及timit模塊來測試程序的速度，找出程序中到底是哪裏很慢，進而對這部分代碼獨立出來進行調優的工作。

• compileall: Python程序是通過解釋器執行的，解釋器的輸入是原有程序的字節碼編譯版本。這個字節碼編譯版本可以在程序執行時動態地生成，也可以在程序打包的時候就生成。compileall模塊可以處理程序打包的事宜，它暴露出了打包相關的接口，該接口能夠被安裝程序和打包工具用來生成包含模塊字節碼的文件。同時，在開發環境中，compileall模塊也可以用來驗證源文件是否包含了語法錯誤。

• YAPF：Google開源的Python代碼格式化工具。

• iPDB: iPDB是一個極好的工具，我已經用它查出了很多匪夷所思的bug。pip install ipdb 安裝該工具，然後在你的代碼中import ipdb; ipdb.set_trace()，然後你會在你的程序運行時，獲得一個很好的交互式提示。它每次執行程序的一行並且檢查變量。

• pycallgraph: 在一些場合，我使用pycallgraph來追蹤性能問題。它可以創建函數調用時間和次數的圖表。

• objgraph: objgraph對於查找內存泄露非常有用。

11. Python代碼微優化之加快查找

collections.OrderedDict類：
def __setitem__(self, key, value, dict_setitem=dict.__setitem__):    if key not in self:
        root = self.__root        last = root[0]        last[1] = root[0] = self.__map[key] = [last, root, key]    return dict_setitem(self, key, value)

注意最後一個參數：dict_setitem=dict.setitem。如果你仔細想就會感覺有道理。將值關聯到鍵上，你只需要給setitem傳遞三個參數：要設置的鍵，與鍵關聯的值，傳遞給內建dict類的setitem類方法。等會，好吧，也許最後一個參數沒什麼意義。 最後一個參數其實是將一個函數綁定到局部作用域中的一個函數上。具體是通過將dict.setitem賦值爲參數的默認值。這裏還有另一個例子：

def not_list_or_dict(value):
  return not (isinstance(value, dict) or isinstance(value, list))
def not_list_or_dict(value, _isinstance=isinstance, _dict=dict, _list=list):
  return not (_isinstance(value, _dict) or _isinstance(value, _list))

這裏我們做同樣的事情，把本來將會在內建命名空間中的對象綁定到局部作用域中去。因此，python將會使用LOCAL_FAST而不是LOAD_GLOBAL（全局查找）。那麼這到底有多快呢？我們做個簡單的測試：

$ python -m timeit -s 'def not_list_or_dict(value): return not (isinstance(value, dict) or isinstance(value, list))' 'not_list_or_dict(50)'1000000 loops, best of 3: 0.48 usec per loop$ python -m timeit -s 'def not_list_or_dict(value, _isinstance=isinstance, _dict=dict, _list=list): return not (_isinstance(value, _dict) or _isinstance(value, _list))' 'not_list_or_dict(50)'1000000 loops, best of 3: 0.423 usec per loop

換句話說，大概有11.9%的提升 [2]。比我在文章開始處承諾的5%還多！

12. 包管理

Python世界最棒的地方之一，就是大量的第三方程序包。同樣，管理這些包也非常容易。按照慣例，會在 requirements.txt 文件中列出項目所需要的包。每個包占一行，通常還包含版本號。

pelican==3.3Markdown

pelican-extended-sitemap==1.0.0

13. Python函數參數默認值的陷阱和原理深究

Python 2.7.9 (default, Dec 19 2014, 06:05:48)

[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.56)] on darwin

Type "help", "copyright", "credits" or "license" for more information.>>> def generate_new_list_with(my_list=[], element=None):

... my_list.append(element)

... return my_list

...>>> list_1 = generate_new_list_with(element=1)>>> list_1

[1]>>> list_2 = generate_new_list_with(element=2)>>> list_2

[1, 2]>>>

可見代碼運行結果並不和我們預期的一樣。list_2在函數的第二次調用時並沒有得到一個新的list並填入2，而是在第一次調用結果的基礎上append了一個2。爲什麼會發生這樣在其他編程語言中簡直就是設計bug一樣的問題呢？ 可見如果參數默認值是在函數編譯compile階段就已經被確定。之後所有的函數調用時，如果參數不顯示的給予賦值，那麼所謂的參數默認值不過是一個指向那個在compile階段就已經存在的對象的指針。如果調用函數時，沒有顯示指定傳入參數值得話。那麼所有這種情況下的該參數都會作爲編譯時創建的那個對象的一種別名存在。如果參數的默認值是一個不可變(Imuttable)數值，那麼在函數體內如果修改了該參數，那麼參數就會重新指向另一個新的不可變值。而如果參數默認值是和本文最開始的舉例一樣，是一個可變對象(Muttable)，那麼情況就比較糟糕了。所有函數體內對於該參數的修改，實際上都是對compile階段就已經確定的那個對象的修改。

14. 單下劃線（_）

1、在解釋器中：在這種情況下，“_”代表交互式解釋器會話中上一條執行的語句的結果。這種用法首先被標準CPython解釋器採用，然後其他類型的解釋器也先後採用。

>>> _ Traceback (most recent call last): 

File "<stdin>", line 1, in <module> NameError: name '_' is not defined >>> 42>>> _ 42>>> 'alright!' if _ else ':(''alright!'>>> _ 'alright!'

2、作爲一個名稱：這與上面一點稍微有些聯繫，此時“”作爲臨時性的名稱使用。這樣，當其他人閱讀你的代碼時將會知道，你分配了一個特定的名稱，但是並不會在後面再次用到該名稱。例如，下面的例子中，你可能對循環計數中的實際值並不感興趣，此時就可以使用“”。

n = 42for _ in range(n): 

    do_something()

3、國際化：也許你也曾看到”_“會被作爲一個函數來使用。這種情況下，它通常用於實現國際化和本地化字符串之間翻譯查找的函數名稱，這似乎源自並遵循相應的C約定。例如，在Django文檔“轉換”章節中，你將能看到如下代碼：

from django.utils.translation import ugettext as _ 

from django.http import HttpResponse 

def my_view(request): 

    output = _("Welcome to my site.") 

    return HttpResponse(output)

可以發現，場景二和場景三中的使用方法可能會相互衝突，所以我們需要避免在使用“”作爲國際化查找轉換功能的代碼塊中同時使用“”作爲臨時名稱。

15. 名稱前的單下劃線（如：_shahriar）

程序員使用名稱前的單下劃線，用於指定該名稱屬性爲“私有”。這有點類似於慣例，爲了使其他人（或你自己）使用這些代碼時將會知道以“”開頭的名稱只供內部使用。正如Python文檔中所述：
以下劃線 _ 爲前綴的名稱（如pam）應該被視爲API中非公開的部分（不管是函數、方法還是數據成員）。此時，應該將它們看作是一種實現細節，在修改它們時無需對外部通知。
正如上面所說，這確實類似一種慣例，因爲它對解釋器來說確實有一定的意義，如果你寫了代碼 : from <模塊/包名> import
，那麼以 開頭的名稱都不會被導入，除非模塊或包中的 all
列表顯式地包含了它們。瞭解更多請查看 Importing in Python

16. 名稱前的雙下劃線（如：__shahriar）

名稱（具體爲一個方法名）前雙下劃線 _ 的用法並不是一種慣例，對解釋器來說它有特定的意義。Python中的這種用法是爲了避免與子類定義的名稱衝突。Python文檔指出，spam 這種形式（至少兩個前導下劃線，最多一個後續下劃線）的任何標識符將會被 正如所預料的，“_internal_use”並未改變，而“method_name”卻被變成了“_ClassName__method_name”。此時，如果你創建A的一個子類B，那麼你將不能輕易地覆寫A中的方法“__method_name”。spam 這種形式原文取代，在這裏 classname 是去掉前導下劃線的當前類名。例如下面的例子：

>>> class A(object): ... def _internal_use(self): ... pass... def __method_name(self): ... pass... >>> dir(A()) 

['_A__method_name', ..., '_internal_use']

正如所預料的，“_internal_use”並未改變，而“method_name”卻被變成了“_ClassNamemethod_name”。此時，如果你創建A的一個子類B，那麼你將不能輕易地覆寫A中的方法“__method_name”。

17. 名稱前後的雙下劃線（如：init）

這種用法表示Python中特殊的方法名。其實，這只是一種慣例，對Python系統來說，這將確保不會與用戶自定義的名稱衝突。通常，你將會覆寫這些方法，並在裏面實現你所需要的功能，以便Python調用它們。例如，當定義一個類時，你經常會覆寫“init”方法。
雖然你也可以編寫自己的特殊方法名，但不要這樣做。

17. 隱藏特性 1，函數unpack

def foo(x, y):

 print x, y

alist = [1, 2]

adict = {'x': 1, 'y': 2}

foo(*alist) # 1, 2foo(**adict) # 1, 2

18. 隱藏特性 2， 鏈式比較操作符

>>> x = 3>>> 1 < x < 5True>>> 4 > x >=3True

19. 隱藏特性 3，函數的默認參數

>>> def foo(x=[]):

... x.append(1)

... print x

...>>> foo()

[1]>>> foo()

[1, 1]

更安全的做法是：

>>> def foo(x=None):... if x is None:... x = []... x.append(1)... print x

...>>> foo()

[1]>>> foo()

[1]

>>>

20. 隱藏特性 4，字典的get方法

21. 隱藏特性 5，帶關鍵字的格式化

>>> print "Hello %(name)s !" % {'name': 'James'}

Hello James !>>> print "I am years %(age)i years old" % {'age': 18}

I am years 18 years old

更新些的格式化:

>>> print "Hello {name} !".format(name="James")

Hello James !

22. 隱藏特性 6，切片操作的步長參數

可以用步長 -1 來反轉鏈表：>>> a = [1, 2, 3, 4, 5]>>> a[::2]

[1, 3, 5]>>> a[::-1]

[5, 4, 3, 2, 1]>>>

23. 隱藏特性 7，嵌套列表推導式

[(i, j) for i in range(3) for j in range(i)]

[(1, 0), (2, 0), (2, 1)]

列表推導構造permutation：可以用 itertools.permutations 來實現。

In[47]: a = 'abcd'In[48]: [i+j+k for i in a for j in a.replace(i,'') for k in a.replace(i,'').replace(j,'')]Out[48]: 

['abc', 'abd', 'acb', 'acd', 'adb', 'adc', 'bac', 'bad', 'bca', 'bcd', 'bda', 'bdc', 'cab', 'cad', 'cba', 'cbd', 'cda', 'cdb', 'dab', 'dac', 'dba', 'dbc', 'dca', 'dcb']

24. 隱藏特性 8，print 重定向輸出到文件

注意打開的模式: “w+” 而不能 “w” , 當然 “a” 是可以的

>>> print >> open("somefile", "w+"), "Hello World"

25. 隱藏特性 9， Python3中的元組unpack

>>> a, b, *rest = range(10)

>>> a0>>> b1>>> rest

[2, 3, 4, 5, 6, 7, 8, 9]

>>>

>>> first, second, *rest, last = range(10)

>>> first0>>> second1>>> last9>>> rest

[2, 3, 4, 5, 6, 7, 8]

26. 隱藏特性 10，pow的第三個參數

其實第三個參數是來求模的: pow(x, y, z) == (x ** y) % z，注意，內置的 pow 和 math.pow 並不是一個函數，後者只接受2個參數。

>>> pow(4, 2, 2)0>>> pow(4, 2, 3)1

27. 隱藏特性 11，enumerate還有第二個參數

enumerate 很贊，可以給我們索引和序列值的對, 但是它還有第二個參數，這個參數用來: 指明索引的起始值。

>>> lst = ["a", "b", "c"]>>> list(enumerate(lst, 1))

[(1, 'a'), (2, 'b'), (3, 'c')]

28. 隱藏特性 12，顯式的聲明一個集合

在Python 2.7 之後可以這麼聲明一個集合。
>>> {1,2,3}

set([1, 2, 3])

29. 隱藏特性 13，用切片來刪除序列的某一段

>>> a = [1, 2, 3, 4, 5, 6, 7]>>> a[1:4] = []>>> a

[1, 5, 6, 7]

當然用 del a[1:4] 也是可以的，去除偶數項(偶數索引的):

>>> a = [0, 1, 2, 3, 4, 5, 6, 7]

>>> del a[::2]

>>> a[1, 3, 5, 7]

30. 隱藏特性 14，isinstance可以接收一個元組

這個真的鮮爲人知, 我們可以用 isinstance(x, (float, int)) 來判斷 x 是不是數，也就是那個元組裏面是 或 的關係，只要是其中一個的實例就返回 True。

>>> isinstance(1, (float, int))True>>> isinstance(1.3, (float, int))True>>> isinstance("1.3", (float, int))False

31. 讓關鍵代碼依賴於外部包

雖然Python讓許多編程任務變得容易，但它可能並不總能爲緊急的任務提供最佳性能。你可以爲緊急的任務使用C、C++或機器語言編寫的外部包，這樣可以提高應用程序的性能。這些包都是不能跨平臺的，這意味着你需要根據你正在使用的平臺，尋找合適的包。簡而言之，這個方案放棄了一些應用程序的可移植性，以換取只有在特定主機上直接編程才能獲得的程序性能。這裏有一些你應該考慮加入到你的“性能兵工廠”的包：

Cython
PyInlne
PyPy
Pyrex

這些包以不同的方式提高性能。例如，Pyrex能夠擴展Python所能做的事情，例如使用C的數據類型來讓內存任務更加有效或直接。PyInIne讓你在Python應用程序中直接使用C代碼。程序中的內聯代碼單獨編譯，但它在利用C語言所能提供的效率的同時，也讓所有的代碼都在同一個地方。

32. 排序時使用鍵（key）

有很多老的Python排序代碼，它們在你創建一個自定義的排序時花費你的時間，但在運行時確實能加速執行排序過程。元素排序的最好方法是儘可能使用鍵（key）和默認的sort()排序方法。例如，考慮下面的代碼：

import operator

somelist = [(1, 5, 8), (6, 2, 4), (9, 7, 5)]

somelist.sort(key=operator.itemgetter(0))

somelist

#Output = [(1, 5, 8), (6, 2, 4), (9, 7, 5)]

somelist.sort(key=operator.itemgetter(1))

somelist

#Output = [(6, 2, 4), (1, 5, 8), (9, 7, 5)]

somelist.sort(key=operator.itemgetter(2))

somelist

每一個實例中，根據你選擇的作爲key參數部分的索引，數組進行了排序。類似於利用數字進行排序，這種方法同樣適用於利用字符串排序。

33. 優化循環

每種編程語言都會強調需要優化循環。當使用Python的時候，你可以依靠大量的技巧使得循環運行得更快。然而，開發者經常漏掉的一個方法是：避免在一個循環中使用點操作。例如，考慮下面的代碼：

lowerlist = ['this', 'is', 'lowercase']

upper = str.upperupperlist = []

append = upperlist.appendfor word in lowerlist:

 append(upper(word))

 print(upperlist) #Output = ['THIS', 'IS', 'LOWERCASE']

每一次你調用方法str.upper，Python都會求該方法的值。然而，如果你用一個變量代替求得的值，值就變成了已知的，Python就可以更快地執行任務。優化循環的關鍵，是要減少Python在循環內部執行的工作量，因爲Python原生的解釋器在那種情況下，真的會減緩執行的速度。
（注意：優化循環的方法有很多，這只是其中的一個。例如，許多程序員都會說，列表推導是在循環中提高執行速度的最好方式。這裏的關鍵是，優化循環是程序取得更高的執行速度的更好方式之一。）

34. 嘗試多種編碼方法

如果每次你創建一個應用程序都是用相同的編碼方法，幾乎肯定會導致一些你的應用程序比它能夠達到的運行效率慢的情況。作爲分析過程的一部分，你可以嘗試一些實驗。例如，在一個字典中管理一些元素，你可以採用安全的方法確定元素是否已經存在並更新，或者你可以直接添加元素，然後作爲異常處理該元素不存在情況。考慮第一個編碼的例子：

n = 16myDict = {}for i in range(0, n): char = 'abcd'[i%4] if char not in myDict:

 myDict[char] = 0

 myDict[char] += 1

 print(myDict)

這段代碼通常會在myDict開始爲空時運行得更快。然而，當mydict通常被數據填充（或者至少大部分被充填）時，另一種方法效果更好。

n = 16myDict = {}for i in range(0, n): char = 'abcd'[i%4] try:

 myDict[char] += 1

 except KeyError:

 myDict[char] = 1

 print(myDict)

兩種情況下具有相同的輸出：{‘d’: 4, ‘c’: 4, ‘b’: 4, ‘a’: 4}。唯一的不同是這個輸出是如何得到的。跳出固定的思維模式，創造新的編碼技巧，能夠幫助你利用你的應用程序獲得更快的結果。

35. 使用列表推導式

一個列表推導式包含以下幾個部分：
一個輸入序列
一個表示輸入序列成員的變量
一個可選的斷言表達式
一個將輸入序列中滿足斷言表達式的成員變換成輸出列表成員的輸出表達式

num = [1, 4, -5, 10, -7, 2, 3, -1]

filtered_and_squared = []for number in num:    if number > 0:

        filtered_and_squared.append(number ** 2)

print filtered_and_squared# [1, 16, 100, 4, 9]

而如果使用filter、lambda和map函數，則能夠將代碼大大簡化：

num = [1, 4, -5, 10, -7, 2, 3, -1]

filtered_and_squared = map(lambda x: x ** 2, filter(lambda x: x > 0, num))print filtered_and_squared

# [1, 16, 100, 4, 9]

## 更簡化的一種寫法 

num = [1, 4, -5, 10, -7, 2, 3, -1]

filtered_and_squared = [ x**2 for x in num if x > 0]print filtered_and_squared

# [1, 16, 100, 4, 9]

[圖片上傳失敗...(image-372582-1565252337522)]

comprehension.jpg

列表推導也可能會有一些負面效應，那就是整個列表必須一次性加載於內存之中，這對上面舉的例子而言不是問題，甚至擴大若干倍之後也都不是問題。但是總會達到極限，內存總會被用完。
針對上面的問題，生成器(Generator)能夠很好的解決。生成器表達式不會一次將整個列表加載到內存之中，而是生成一個生成器對象(Generator objector)，所以一次只加載一個列表元素。
生成器表達式同列表推導式有着幾乎相同的語法結構，區別在於生成器表達式是被圓括號包圍，而不是方括號：

num = [1, 4, -5, 10, -7, 2, 3, -1]

filtered_and_squared = ( x**2 for x in num if x > 0 )

print filtered_and_squared# <generator object <genexpr> at 0x00583E18>for item in filtered_and_squared:

    print item# 1, 16, 100 4,9

這比列表推導效率稍微提高一些，讓我們再一次改造一下代碼：

num = [1, 4, -5, 10, -7, 2, 3, -1]def square_generator(optional_parameter):

    return (x ** 2 for x in num if x > optional_parameter)print square_generator(0)# <generator object <genexpr> at 0x004E6418># Option Ifor k in square_generator(0):    print k# 1, 16, 100, 4, 9# Option IIg = list(square_generator(0))print g# [1, 16, 100, 4, 9]

除非特殊的原因，應該經常在代碼中使用生成器表達式。但除非是面對非常大的列表，否則是不會看出明顯區別的。 再來看一個通過兩階列表推導式遍歷目錄的例子：

import os

def tree(top):    for path, names, fnames in os.walk(top):        for fname in fnames:

            yield os.path.join(path, fname)for name in tree('C:\Users\XXX\Downloads\Test'):

    print name

36. 裝飾器(Decorators)

裝飾器爲我們提供了一個增加已有函數或類的功能的有效方法。聽起來是不是很像Java中的面向切面編程(Aspect-Oriented Programming)概念？兩者都很簡單，並且裝飾器有着更爲強大的功能。舉個例子，假定你希望在一個函數的入口和退出點做一些特別的操作(比如一些安全、追蹤以及鎖定等操作)就可以使用裝飾器。
裝飾器是一個包裝了另一個函數的特殊函數：主函數被調用，並且其返回值將會被傳給裝飾器，接下來裝飾器將返回一個包裝了主函數的替代函數，程序的其他部分看到的將是這個包裝函數。

import timefrom functools import wrapsdef timethis(func):

    '''

    Decorator that reports the execution time.

    '''    @wraps(func)

    def wrapper(*args, **kwargs):

        start = time.time()

        result = func(*args, **kwargs)

        end = time.time()

        print(func.__name__, end-start)        return result    return wrapper@timethisdef countdown(n):

    while n > 0:

        n -= 1countdown(100000)# ('countdown', 0.006999969482421875)

37. 上下文管理庫(ContextLib)

contextlib模塊包含了與上下文管理器和with聲明相關的工具。通常如果你想寫一個上下文管理器，則你需要定義一個類包含enter方法以及exit方法，例如：

import timeclass demo:

    def __init__(self, label):        self.label = label    def __enter__(self):        self.start = time.time()    def __exit__(self, exc_ty, exc_val, exc_tb):        end = time.time()

        print('{}: {}'.format(self.label, end - self.start))

完整的例子在此：

import timeclass demo:

    def __init__(self, label):        self.label = label    def __enter__(self):        self.start = time.time()    def __exit__(self, exc_ty, exc_val, exc_tb):        end = time.time()

        print('{}: {}'.format(self.label, end - self.start))

with demo('counting'):

    n = 10000000

    while n > 0:

        n -= 1# counting: 1.36000013351

上下文管理器被with聲明所激活，這個API涉及到兩個方法。 enter方法，當執行流進入with代碼塊時，enter方法將執行。並且它將返回一個可供上下文使用的對象。
當執行流離開with代碼塊時，exit方法被調用，它將清理被使用的資源。

利用@contextmanager裝飾器改寫上面那個例子：

from contextlib import contextmanagerimport time@contextmanagerdef demo(label):

    start = time.time()    try:        yield

    finally:

        end = time.time()

        print('{}: {}'.format(label, end - start))with demo('counting'):

    n = 10000000

    while n > 0:

        n -= 1# counting: 1.32399988174

看上面這個例子，函數中yield之前的所有代碼都類似於上下文管理器中enter方法的內容。而yield之後的所有代碼都如exit方法的內容。如果執行過程中發生了異常，則會在yield語句觸發。

38. 描述器(Descriptors)

描述器決定了對象屬性是如何被訪問的。描述器的作用是定製當你想引用一個屬性時所發生的操作。
構建描述器的方法是至少定義以下三個方法中的一個。需要注意，下文中的instance是包含被訪問屬性的對象實例，而owner則是被描述器修辭的類。
get(self, instance, owner) – 這個方法是當屬性被通過(value = obj.attr)的方式獲取時調用，這個方法的返回值將被賦給請求此屬性值的代碼部分。 set(self, instance, value) – 這個方法是當希望設置屬性的值(obj.attr = ‘value’)時被調用，該方法不會返回任何值。 delete(self, instance) – 當從一個對象中刪除一個屬性時(del obj.attr)，調用此方法。 譯者注：對於instance和owner的理解，考慮以下代碼：

class Celsius(object):

    def __init__(self, value=0.0):        self.value = float(value)    def __get__(self, instance, owner):        return self.value    def __set__(self, instance, value):        self.value = float(value)class Temperature(object):

    celsius = Celsius()

temp=Temperature()

temp.celsius #calls Celsius.__get__

39. Zipping and unzipping lists and iterables

>>> a = [1, 2, 3]>>> b = ['a', 'b', 'c']>>> z = zip(a, b)>>> z

[(1, 'a'), (2, 'b'), (3, 'c')]>>> zip(*z)

[(1, 2, 3), ('a', 'b', 'c')]

40. Grouping adjacent list items using zip

>>> a = [1, 2, 3, 4, 5, 6]>>> # Using iterators>>> group_adjacent = lambda a, k: zip(*([iter(a)] * k))>>> group_adjacent(a, 3)

[(1, 2, 3), (4, 5, 6)]>>> group_adjacent(a, 2)

[(1, 2), (3, 4), (5, 6)]>>> group_adjacent(a, 1)

[(1,), (2,), (3,), (4,), (5,), (6,)]>>> # Using slices>>> from itertools import islice>>> group_adjacent = lambda a, k: zip(*(islice(a, i, None, k) for i in range(k)))>>> group_adjacent(a, 3)

[(1, 2, 3), (4, 5, 6)]>>> group_adjacent(a, 2)

[(1, 2), (3, 4), (5, 6)]>>> group_adjacent(a, 1)

[(1,), (2,), (3,), (4,), (5,), (6,)]

41. Sliding windows (n-grams) using zip and iterators

>>> from itertools import islice>>> def n_grams(a, n):... z = (islice(a, i, None) for i in range(n))... return zip(*z)

...>>> a = [1, 2, 3, 4, 5, 6]>>> n_grams(a, 3)

[(1, 2, 3), (2, 3, 4), (3, 4, 5), (4, 5, 6)]>>> n_grams(a, 2)

[(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)]>>> n_grams(a, 4)

[(1, 2, 3, 4), (2, 3, 4, 5), (3, 4, 5, 6)]

42. Inverting a dictionary using zip

>>> m = {'a': 1, 'b': 2, 'c': 3, 'd': 4}>>> m.items()

[('a', 1), ('c', 3), ('b', 2), ('d', 4)]>>> zip(m.values(), m.keys())

[(1, 'a'), (3, 'c'), (2, 'b'), (4, 'd')]>>> mi = dict(zip(m.values(), m.keys()))>>> mi

{1: 'a', 2: 'b', 3: 'c', 4: 'd'}

43. Flattening lists

>>> a = [[1, 2], [3, 4], [5, 6]]>>> list(itertools.chain.from_iterable(a))

[1, 2, 3, 4, 5, 6]

>>> sum(a, [])

[1, 2, 3, 4, 5, 6]

>>> [x for l in a for x in l]

[1, 2, 3, 4, 5, 6]

>>> a = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]

>>> [x for l1 in a for l2 in l1 for x in l2]

[1, 2, 3, 4, 5, 6, 7, 8]

>>> a = [1, 2, [3, 4], [[5, 6], [7, 8]]]

>>> flatten = lambda x: [y for l in x for y in flatten(l)] if type(x) is list else [x]

>>> flatten(a)

[1, 2, 3, 4, 5, 6, 7, 8]

44. Dictionary comprehensions

>>> m = {x: x ** 2 for x in range(5)}>>> m

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}>>> m = {x: 'A' + str(x) for x in range(10)}>>> m

{0: 'A0', 1: 'A1', 2: 'A2', 3: 'A3', 4: 'A4', 5: 'A5', 6: 'A6', 7: 'A7', 8: 'A8', 9: 'A9'}

45. 常犯錯誤，濫用表達式作爲函數參數默認值

Python允許開發者指定一個默認值給函數參數，雖然這是該語言的一個特徵，但當參數可變時，很容易導致混亂，例如，下面這段函數定義：

>>> def foo(bar=[]): # bar is optional and defaults to [] if not specified... bar.append("baz") # but this line could be problematic, as we'll see...... return bar

在上面這段代碼裏，一旦重複調用foo()函數（沒有指定一個bar參數），那麼將一直返回’bar’，因爲沒有指定參數，那麼foo()每次被調用的時候，都會賦予[]。下面來看看，這樣做的結果：

>>> foo()

["baz"]>>> foo()

["baz", "baz"]>>> foo()

["baz", "baz", "baz"]

解決方案：

>>> def foo(bar=None):... if bar is None: # or if not bar:... bar = []... bar.append("baz")... return bar

...>>> foo()

["baz"]>>> foo()

["baz"]>>> foo()

["baz"]

46. 誤解Python規則範圍

Python的作用域解析是基於LEGB規則，分別是Local、Enclosing、Global、Built-in。實際上，這種解析方法也有一些玄機，看下面這個例子：

>>> x = 10>>> def foo():

... x += 1... print x

...>>> foo()

Traceback (most recent call last):

 File "<stdin>", line 1, in <module>

 File "<stdin>", line 2, in fooUnboundLocalError: local variable 'x' referenced before assignment

許多人會感動驚訝，當他們在工作的函數體裏添加一個參數語句，會在先前工作的代碼裏報UnboundLocalError錯誤（ 點擊這裏查看更詳細描述）。 在使用列表時，開發者是很容易犯這種錯誤的，看看下面這個例子：

>>> lst = [1, 2, 3]>>> def foo1():

... lst.append(5) # This works ok......>>> foo1()>>> lst

[1, 2, 3, 5]>>> lst = [1, 2, 3]>>> def foo2():

... lst += [5] # ... but this bombs!...>>> foo2()

Traceback (most recent call last):

 File "<stdin>", line 1, in <module>

 File "<stdin>", line 2, in fooUnboundLocalError: local variable 'lst' referenced before assignment

爲什麼foo2失敗而foo1運行正常？ 答案與前面那個例子是一樣的，但又有一些微妙之處。foo1沒有賦值給lst，而foo2賦值了。lst += [5]實際上就是lst = lst + [5]，試圖給lst賦值（因此，假設Python是在局部作用域裏）。然而，我們正在尋找指定給lst的值是基於lst本身，其實尚未確定。

47. 修改遍歷列表

>>> odd = lambda x : bool(x % 2)

>>> numbers = [n for n in range(10)]

>>> for i in range(len(numbers)):

... if odd(numbers[i]):

... del numbers[i] # BAD: Deleting item from a list while iterating over it

...

Traceback (most recent call last):

 File "<stdin>", line 2, in <module>

IndexError: list index out of range

在遍歷的時候，對列表進行刪除操作，這是很低級的錯誤。稍微有點經驗的人都不會犯。 對上面的代碼進行修改，正確地執行：

>>> odd = lambda x : bool(x % 2)>>> numbers = [n for n in range(10)]>>> numbers[:] = [n for n in numbers if not odd(n)] # ahh, the beauty of it all>>> numbers

[0, 2, 4, 6, 8]

48. 合理使用copy與deepcopy

對於dict和list等數據結構的對象，直接賦值使用的是引用的方式。而有些情況下需要複製整個對象，這時可以使用copy包裏的copy和deepcopy，這兩個函數的不同之處在於後者是遞歸複製的。效率也不一樣：（以下程序在ipython中運行）
timeit後面的-n表示運行的次數，後兩行對應的是兩個timeit的輸出，下同。由此可見後者慢一個數量級。

import copya = range(100000)

%timeit -n 10 copy.copy(a) # 運行10次 copy.copy(a)%timeit -n 10 copy.deepcopy(a)10 loops, best of 3: 1.55 ms per loop10 loops, best of 3: 151 ms per loop

49. 合理使用生成器（generator）和yield

%timeit -n 100 a = (i for i in range(100000))

%timeit -n 100 b = [i for i in range(100000)]100 loops, best of 3: 1.54 ms per loop100 loops, best of 3: 4.56 ms per loop

使用()得到的是一個generator對象，所需要的內存空間與列表的大小無關，所以效率會高一些。在具體應用上，比如set(i for i in range(100000))會比set([i for i in range(100000)])快。
但是對於需要循環遍歷的情況：

%timeit -n 10 for x in (i for i in range(100000)): pass

%timeit -n 10 for x in [i for i in range(100000)]: pass10 loops, best of 3: 6.51 ms per loop10 loops, best of 3: 5.54 ms per loop

後者的效率反而更高，但是如果循環裏有break,用generator的好處是顯而易見的。yield也是用於創建generator：

50. 使用級聯比較x < y < z

x, y, z = 1,2,3%timeit -n 1000000 if x < y < z:pass

%timeit -n 1000000 if x < y and y < z:pass1000000 loops, best of 3: 101 ns per loop1000000 loops, best of 3: 121 ns per loop

x < y < z效率略高，而且可讀性更好。

51. while 1 比 while True 更快

def while_1():

 n = 100000

 while 1:

 n -= 1

 if n <= 0: breakdef while_true():

 n = 100000

 while True:

 n -= 1

 if n <= 0: break m, n = 1000000, 1000000 %timeit -n 100 while_1()

%timeit -n 100 while_true()100 loops, best of 3: 3.69 ms per loop100 loops, best of 3: 5.61 ms per loop

while 1 比 while true快很多，原因是在python2.x中，True是一個全局變量，而非關鍵字。

52. 使用**而不是pow

%timeit -n 10000 c = pow(2,20)

%timeit -n 10000 c = 2**2010000 loops, best of 3: 284 ns per loop10000 loops, best of 3: 16.9 ns per loop

53. 使用 cProfile, cStringIO 和 cPickle等用c實現相同功能（分別對應profile, StringIO, pickle）的包

import cPickleimport pickle

a = range(10000)

%timeit -n 100 x = cPickle.dumps(a)

%timeit -n 100 x = pickle.dumps(a)100 loops, best of 3: 1.58 ms per loop100 loops, best of 3: 17 ms per loop

由c實現的包，速度快10倍以上！

54. 使用最佳的反序列化方式

下面比較了eval, cPickle, json方式三種對相應字符串反序列化的效率，可見json比cPickle快近3倍，比eval快20多倍。

import jsonimport cPickle

a = range(10000)s1 = str(a)s2 = cPickle.dumps(a)s3 = json.dumps(a)%timeit -n 100 x = eval(s1)

%timeit -n 100 x = cPickle.loads(s2)

%timeit -n 100 x = json.loads(s3)100 loops, best of 3: 16.8 ms per loop100 loops, best of 3: 2.02 ms per loop100 loops, best of 3: 798 μs per loop

55. 怎麼纔算精通python

這個問題比較難回答，按照自己的看法整理了一些觀點。不要問我是按什麼標準整理的，我只能說，整理的這些點，第一，在我看來都說得不錯；第二，我自己都會去按照這些點來看看自己離 “精通” python還有多遠。

1. 熟悉語法以及原聲數據結構

2. 熟悉基本實現中的性能特點，就是知道什麼操作會慢

3. 會使用profile以及基於profile的性能分析工具

4. 會使用運行時編譯和靜態編譯的工具。pypy，numba，cython，ctypes，original C/C++ extension

5. 熟悉你所在領域的拓展庫，比如我，科學計算方面的庫不要太多，numpy衍生出來的一大堆大堆

6. 瞭解基本的編譯過程，基本的操作系統知識（只要你C、C++學的還行就可以了）

7. 要想精通python，寫的代碼首先得pythonic

8. 研讀牛B的開源代碼，在這過程中會遇到python的許多高階用法

9. 理解裝飾器，生成器，描述符，元類

10. 掌握list comprehension，

11. 多用內置函數：map，reduce，filter，iter，range，divmod，round，chr，enumerate，all，any，slice，zip+

56. python 猴子補丁相關

python裏有一個很奇妙的monkey patch，中文叫做猴子補丁，是指的是在運行時動態替換某些已加載的模塊的實現。第一次瞭解這個概念是在使用gevent的時候，需要把python自帶的socket，os等相關模塊的實現改變成異步形式，但同時不改動python的源代碼。