python3timeit用法

『壹』 如何高效地使用python統計數據的頻率

之前用 Python 寫過一個腳本，用來處理上千萬用戶的一些數據，其中有一個需求是統計用戶的某一數據的去重數量。為了加快程序的速度，我啟用了多進程。但不幸的是，程序跑了近一個星期，還沒處理完。這時，我感覺到了不對，於是開始查看程序的性能瓶頸。
對於統計去重數，我是將用戶的數據放到一個列表中，然後用 len(set(data)) 去統計去重數量。剛開始我以為這的數據量並不大，每個用戶的數據不會過百，我並沒有注意到有的用戶會有上萬條的數據，因此消耗了大量的時間（其實我的腳本消耗時間最大的地方是因為從遠程 redis 中取大量數據時發生長時間的阻塞，甚至連接超時，最後我採用的方式分而治之，每次取少量的數據，這樣大大的提高了性能）。
為了做優化，我開始尋求高效的方法。我發現，有大量的人認為採用字典效率會更高，即：
data_unique = {}.fromkeys(data).keys() len(data_unique)

於是，我做了下測試：
In [1]: import random In [2]: data = [random.randint(0, 1000) for _ in xrange(1000000)] In [3]: %timeit len(set(data)) 10 loops, best of 3: 39.7 ms per loop In [4]: %timeit len({}.fromkeys(data).keys()) 10 loops, best of 3: 43.5 ms per loop

由此可見，採用字典和採用集合的性能是差不多的，甚至可能還要慢些。
在 Python 中其實有很多高效的庫，例如用 numpy、pandas 來處理數據，其性能接近於 C 語言。那麼，我們就用 numpy 和 pandas 來解決這個問題，這里我還比較了獲取去重數據的性能，代碼如下：
import collections import random as py_random import timeit import numpy.random as np_random import pandas as pd DATA_SIZE = 10000000 def py_cal_len(): data = [py_random.randint(0, 1000) for _ in xrange(DATA_SIZE)] len(set(data)) def pd_cal_len(): data = np_random.randint(1000, size=DATA_SIZE) data = pd.Series(data) data_unique = data.value_counts() data_unique.size def py_count(): data = [py_random.randint(0, 1000) for _ in xrange(DATA_SIZE)] collections.Counter(data) def pd_count(): data = np_random.randint(1000, size=DATA_SIZE) data = pd.Series(data) data.value_counts() # Script starts from here if __name__ == "__main__": t1 = timeit.Timer("py_cal_len()", setup="from __main__ import py_cal_len") t2 = timeit.Timer("pd_cal_len()", setup="from __main__ import pd_cal_len") t3 = timeit.Timer("py_count()", setup="from __main__ import py_count") t4 = timeit.Timer("pd_count()", setup="from __main__ import pd_count") print t1.timeit(number=1) print t2.timeit(number=1) print t3.timeit(number=1) print t4.timeit(number=1)

運行結果：
12.438587904 0.435907125473 14.6431810856 0.258564949036

利用 pandas 統計數據的去重數和去重數據，其性能是 Python 原生函數的 10 倍以上。

『貳』 詳解python2 和 python3的區別

Python2.x與3.x版本區別

Python的3.0版本，常被稱為Python 3000，或簡稱Py3k。相對於Python的早期版本，這是一個較大的升級。

為了不帶入過多的累贅，Python 3.0在設計的時候沒有考慮向下相容。

許多針對早期Python版本設計的程式都無法在Python 3.0上正常執行。

為了照顧現有程式，Python 2.6作為一個過渡版本，基本使用了Python 2.x的語法和庫，同時考慮了向Python 3.0的遷移，允許使用部分Python 3.0的語法與函數。

新的Python程式建議使用Python 3.0版本的語法。

除非執行環境無法安裝Python 3.0或者程式本身使用了不支援Python 3.0的第三方庫。目前不支援Python 3.0的第三方庫有Twisted, py2exe, PIL等。

大多數第三方庫都正在努力地相容Python 3.0版本。即使無法立即使用Python 3.0，也建議編寫相容Python 3.0版本的程式，然後使用Python 2.6, Python 2.7來執行。

Python 3.0的變化主要在以下幾個方面:

1. print 函數

print語句沒有了，取而代之的是print()函數。 Python 2.6與Python 2.7部分地支持這種形式的print語法。在Python 2.6與Python 2.7裡面，以下三種形式是等價的：

print"fish"
print("fish")#注意print後面有個空格
print("fish")#print()不能帶有任何其它參數

然而，Python 2.6實際已經支持新的print()語法：

from__future__importprint_function
print("fish","panda",sep=',')

2.Unicode

Python 2 有 ASCII str() 類型，unicode() 是單獨的，不是 byte 類型。

現在， 在 Python 3，我們最終有了 Unicode (utf-8) 字元串，以及一個位元組類：byte 和 bytearrays。

由於 Python3.X 源碼文件默認使用utf-8編碼，這就使得以下代碼是合法的：

>>>中國='china'
>>>print(中國)
china

Python 2.x

>>>str="我愛北京天安門"
>>>str
''
>>>str=u"我愛北京天安門"
>>>str
u''

Python 3.x

>>>str="我愛北京天安門"
>>>str
'我愛北京天安門'

3. 除法運算

Python中的除法較其它語言顯得非常高端，有套很復雜的規則。Python中的除法有兩個運算符，/和//

3.1首先來說/除法:

在python 2.x中/除法就跟我們熟悉的大多數語言，比如Java啊C啊差不多，整數相除的結果是一個整數，把小數部分完全忽略掉，浮點數除法會保留小數點的部分得到一個浮點數的結果。

在python 3.x中/除法不再這么做了，對於整數之間的相除，結果也會是浮點數。

Python 2.x:

>>>1/2
0
>>>1.0/2.0
0.5

Python 3.x :

>>>1/2
0.5

而對於//除法，這種除法叫做floor除法，會對除法的結果自動進行一個floor操作，在python 2.x和python 3.x中是一致的。

python 2.x :

>>>-1//2
-1

python 3.x :

>>>-1//2
-1

注意的是並不是舍棄小數部分，而是執行floor操作，如果要截取小數部分，那麼需要使用math模塊的trunc函數

python 3.x :

>>>importmath
>>>math.trunc(1/2)
0
>>>math.trunc(-1/2)
0

4. 異常

在 Python 3 中處理異常也輕微的改變了，在 Python 3 中我們現在使用 as 作為關鍵詞。

捕獲異常的語法由except exc, var改為except exc as var。

使用語法except (exc1, exc2) as var可以同時捕獲多種類別的異常。 Python 2.6已經支持這兩種語法。

• 1. 在2.x時代，所有類型的對象都是可以被直接拋出的，在3.x時代，只有繼承自BaseException的對象才可以被拋出。

• 2. 2.x raise語句使用逗號將拋出對象類型和參數分開，3.x取消了這種奇葩的寫法，直接調用構造函數拋出對象即可。

在2.x時代，異常在代碼中除了表示程序錯誤，還經常做一些普通控制結構應該做的事情，在3.x中可以看出，設計者讓異常變的更加專一，只有在錯誤發生的情況才能去用異常捕獲語句來處理。

5. xrange

在 Python 2 中 xrange() 創建迭代對象的用法是非常流行的。比如： for 循環或者是列表/集合/字典推導式。

這個表現十分像生成器（比如。"惰性求值"）。但是這個 xrange-iterable 是無窮的，意味著你可以無限遍歷。

由於它的惰性求值，如果你不得僅僅不遍歷它一次，xrange() 函數 比 range() 更快（比如 for 循環）。盡管如此，對比迭代一次，不建議你重復迭代多次，因為生成器每次都從頭開始。

在 Python 3 中，range() 是像 xrange() 那樣實現以至於一個專門的 xrange() 函數都不再存在（在 Python 3 中 xrange() 會拋出命名異常）。

Python 3

importtimeit
n=10000
deftest_range(n):
returnforiinrange(n):
pass
deftest_xrange(n):
foriinxrange(n):
pass

Python 2

print'Python',python_version()
print'
timingrange()'
%timeittest_range(n)
print'

timingxrange()'
%timeittest_xrange(n)
Python2.7.6
timingrange()
1000loops,bestof3:433µsperloop
timingxrange()1000loops,bestof3:350µsperloop
Python2.7.6
timingrange()
1000loops,bestof3:433µsperloop
timingxrange()
1000loops,bestof3:350µsperloop

Python 3

print('Python',python_version())
print('
timingrange()')
%timeittest_range(n)
Python3.4.1
timingrange()
1000loops,bestof3:520µsperloop

print(xrange(10))
---------------------------------------------------------------------------
NameErrorTraceback(mostrecentcalllast)
<ipython-input-5-5d8f9b79ea70>in<mole>()
---->1print(xrange(10))
NameError:name'xrange'isnotdefined

6. 八進制字面量表示

八進制數必須寫成0o777，原來的形式0777不能用了；二進制必須寫成0b111。

新增了一個bin()函數用於將一個整數轉換成二進制字串。 Python 2.6已經支持這兩種語法。

在Python 3.x中，表示八進制字面量的方式只有一種，就是0o1000。

python 2.x

>>>0o1000
512
>>>01000
512

python 3.x

>>>01000
File"<stdin>",line1
01000
^
SyntaxError:invalidtoken
>>>0o1000
512

7.不等運算符

Python 2.x中不等於有兩種寫法 != 和 <>

Python 3.x中去掉了<>, 只有!=一種寫法，還好，我從來沒有使用<>的習慣

8. 去掉了repr表達式``

Python 2.x 中反引號``相當於repr函數的作用

Python 3.x 中去掉了``這種寫法，只允許使用repr函數，這樣做的目的是為了使代碼看上去更清晰么？不過我感覺用repr的機會很少，一般只在debug的時候才用，多數時候還是用str函數來用字元串描述對象。

defsendMail(from_:str,to:str,title:str,body:str)->bool:
pass

多個模塊被改名（根據PEP8）

>>>s=b.decode()
>>>s
'china'
>>>b1=s.encode()
>>>b1
b'china'

3）dict的.keys()、.items 和.values()方法返回迭代器，而之前的iterkeys()等函數都被廢棄。同時去掉的還有 dict.has_key()，用 in替代它吧 。

『叄』 如何讓 Python 像 Julia 一樣快地運行

Julia 與 Python
的比較
我是否應丟棄 Python 和其他語言，使用 Julia 執行技術計算？在看到 http://julialang.org/ 上的基準測試後，人們一定會這么想。Python
和其他高級語言在速度上遠遠有些落後。但是，我想到的第一個問題有所不同：Julia 團隊能否以最適合 Python 的方式編寫 Python 基準測試？
我對這種跨語言比較的觀點是，應該根據要執行的任務來定義基準測試，然後由語言專家編寫執行這些任務的最佳代碼。如果代碼全由一個語言團隊編寫，則存在其他語言未得到最佳使用的風險。
Julia 團隊有一件事做得對，那就是他們將他們使用的代碼發布到了 github 上。具體地講，Python 代碼可在此處找到。
第一眼看到該代碼，就可以證實我所害怕的偏見。該代碼是以 C 風格編寫的，在數組和列表上大量使用了循環。這不是使用 Python 的最佳方式。
我不會責怪 Julia 團隊，因為我很內疚自己也有同樣的偏見。但我受到了殘酷的教訓：付出任何代價都要避免數組或列表上的循環，因為它們確實會拖慢 Python
中的速度，請參閱 Python 不是 C。
考慮到對 C 風格的這種偏見，一個有趣的問題（至少對我而言）是，我們能否改進這些基準測試，更好地使用 Python 及其工具？
在我給出答案之前，我想說我絕不會試圖貶低 Julia。在進一步開發和改進後，Julia 無疑是一種值得關注的語言。我只是想分析 Python
方面的事情。實際上，我正在以此為借口來探索各種可用於讓代碼更快運行的 Python 工具。
在下面的內容中，我使用 Docker 鏡像在 Jupyter Notebook 中使用 Python 3.4.3，其中已安裝了所有的 Python 科學工具組合。我還會通過
Windows 機器上的 Python 2.7.10，使用 Anaconda 來運行代碼。計時是對 Python 3.4.3 執行的。包含下面的所有基準測試的完整代碼的 Notebook 可在此處找到。
鑒於各種社交媒體上的評論，我添加了這樣一句話：我沒有在這里使用 Python 的替代性實現。我沒有編寫任何 C
代碼：如果您不信，可試試尋找分號。本文中使用的所有工具都是 Anaconda 或其他發行版中提供的標準的 Cython 實現。下面的所有代碼都在單個 Notebook中運行。
我嘗試過使用來自 github 的 Julia 微性能文件，但不能使用 Julia 0.4.2 原封不動地運行它。我必須編輯它並將 @timeit 替換為
@time，它才能運行。在對它們計時之前，我還必須添加對計時函數的調用，否則編譯時間也將包含在內。我使用的文件位於此處。我在用於運行 Python 的同一個機器上使用 Julia 命令行介面運行它。
回頁首
計時代碼
Julia 團隊使用的第一項基準測試是 Fibonacci 函數的一段簡單編碼。
def fib(n):
if n<2:
return n
return fib(n-1)+fib(n-2)

此函數的值隨 n 的增加而快速增加，例如：
fib(100) = 354224848179261915075

可以注意到，Python 任意精度 (arbitrary precision) 很方便。在 C 等語言中編寫相同的函數需要花一些編碼工作來避免整數溢出。在 Julia
中，需要使用 BigInt 類型。
所有 Julia 基準測試都與運行時間有關。這是 Julia 中使用和不使用 BigInt 的計時：
0.000080 seconds (149 allocations:10.167 KB)
0.012717 seconds (262.69 k allocations:4.342 MB)

在 Python Notebook 中獲得運行時間的一種方式是使用神奇的 %timeit。例如，在一個新單元中鍵入：
%timeit fib(20)

執行它會獲得輸出：
100 loops, best of 3:3.33 ms per loop

這意味著計時器執行了以下操作：
運行 fib(20) 100 次，存儲總運行時間
運行 fib(20) 100 次，存儲總運行時間
運行 fib(20) 100 次，存儲總運行時間
從 3 次運行中獲取最小的運行時間，將它除以 100，然後輸出結果，該結果就是 fib(20) 的最佳運行時間
這些循環的大小（100 次和 3 次）會由計時器自動調整。可能會根據被計時的代碼的運行速度來更改循環大小。
Python 計時與使用了 BigInt 時的 Julia 計時相比出色得多：3 毫秒與 12 毫秒。在使用任意精度時，Python 的速度是 Julia 的 4
倍。
但是，Python 比 Julia 默認的 64 位整數要慢。我們看看如何在 Python 中強制使用 64 位整數。
回頁首
使用 Cython 編譯
一種編譯方式是使用 Cython 編譯器。這個編譯器是使用 Python
編寫的。它可以通過以下命令安裝：
pip install Cython
如果使用 Anaconda，安裝會有所不同。因為安裝有點復雜，所以我編寫了一篇相關的博客文章：將 Cython For Anaconda 安裝在 Windows 上
安裝後，我們使用神奇的 %load_ext 將 Cython 載入到 Notebook 中：
%load_ext Cython

然後就可以在我們的 Notebook 中編譯代碼。我們只需要將想要編譯的代碼放在一個單元中，包括所需的導入語句，使用神奇的 %%cython 啟動該單元：
%%cython

def fib_cython(n):
if n<2:
return n
return fib_cython(n-1)+fib_cython(n-2)

執行該單元會無縫地編譯這段代碼。我們為該函數使用一個稍微不同的名稱，以反映出它是使用 Cython
編譯的。當然，一般不需要這么做。我們可以將之前的函數替換為相同名稱的已編譯函數。
對它計時會得到：
1000 loops, best of 3:1.22 ms per loop

哇，幾乎比最初的 Python 代碼快 3 倍！我們現在比使用 BigInt 的 Julia 快 100 倍。
我們還可以嘗試靜態類型。使用關鍵字 cpdef 而不是 def 來聲明該函數。它使我們能夠使用相應的 C 類型來鍵入函數的參數。我們的代碼變成了：
%%cython
cpdef long fib_cython_type(long n):
if n<2:
return n
return fib_cython_type(n-1)+fib_cython_type(n-2)

執行該單元後，對它計時會得到：
10000 loops, best of 3:36 µs per loop

太棒了，我們現在只花費了 36 微秒，比最初的基準測試快約 100 倍！這與 Julia 所花的 80 毫秒相比更出色。
有人可能會說，靜態類型違背了 Python
的用途。一般來講，我比較同意這種說法，我們稍後將查看一種在不犧牲性能的情況下避免這種情形的方法。但我並不認為這是一個問題。Fibonacci
函數必須使用整數來調用。我們在靜態類型中失去的是 Python 所提供的任意精度。對於 Fibonacci，使用 C 類型 long
會限制輸入參數的大小，因為太大的參數會導致整數溢出。
請注意，Julia 計算也是使用 64 位整數執行的，因此將我們的靜態類型版本與 Julia 的對比是公平的。
回頁首
緩存計算
我們在保留 Python 任意精度的情況下能做得更好。fib 函數重復執行同一種計算許多次。例如，fib(20) 將調用 fib(19) 和
fib(18)。fib(19) 將調用 fib(18) 和 fib(17)。結果 fib(18) 被調用了兩次。簡單分析表明，fib(17) 將被調用 3
次，fib(16) 將被調用 5 次，等等。
在 Python 3 中，我們可以使用 functools 標准庫來避免這些重復的計算。
from functools import lru_cache as cache
@cache(maxsize=None)
def fib_cache(n):
if n<2:
return n
return fib_cache(n-1)+fib_cache(n-2)

對此函數計時會得到：
1000000 loops, best of 3:910 ns per loop

速度又增加了 40 倍，比最初的 Python 代碼快約 3,600 倍！考慮到我們僅向遞歸函數添加了一條注釋，此結果非常令人難忘。
Python 2.7 中沒有提供這種自動緩存。我們需要顯式地轉換代碼，才能避免這種情況下的重復計算。
def fib_seq(n):
if n < 2:
return n
a,b = 1,0
for i in range(n-1):
a,b = a+b,a
return a

請注意，此代碼使用了 Python 同時分配兩個局部變數的能力。對它計時會得到：
1000000 loops, best of 3:1.77 µs per loop

我們又快了 20 倍！讓我們在使用和不使用靜態類型的情況下編譯我們的函數。請注意，我們使用了 cdef 關鍵字來鍵入局部變數。
%%cython
def fib_seq_cython(n):
if n < 2:
return n
a,b = 1,0
for i in range(n-1):
a,b = a+b,a
return a
cpdef long fib_seq_cython_type(long n):
if n < 2:
return n
cdef long a,b
a,b = 1,0
for i in range(n-1):
a,b = a+b,b
return a

我們可在一個單元中對兩個版本計時：
%timeit fib_seq_cython(20)
%timeit fib_seq_cython_type(20)

結果為：
1000000 loops, best of 3:953 ns per loop
10000000 loops, best of 3:51.9 ns per loop

靜態類型代碼現在花費的時間為 51.9 納秒，比最初的基準測試快約 60,000（六萬）倍。
如果我們想計算任意輸入的 Fibonacci 數，我們應堅持使用無類型版本，該版本的運行速度快 3,500 倍。還不錯，對吧？
回頁首
使用 Numba 編譯
讓我們使用另一個名為 Numba 的工具。它是針對部分 Python 版本的一個即時
(jit) 編譯器。它不是對所有 Python 版本都適用，但在適用的情況下，它會帶來奇跡。
安裝它可能很麻煩。推薦使用像 Anaconda 這樣的 Python 發行版或一個已安裝了 Numba 的 Docker 鏡像。完成安裝後，我們導入它的 jit 編譯器：
from numba import jit

它的使用非常簡單。我們僅需要向想要編譯的函數添加一點修飾。我們的代碼變成了：
@jit
def fib_seq_numba(n):
if n < 2:
return n
(a,b) = (1,0)
for i in range(n-1):
(a,b) = (a+b,a)
return a

對它計時會得到：
1000000 loops, best of 3:225 ns per loop

比無類型的 Cython 代碼更快，比最初的 Python 代碼快約 16,000 倍！
回頁首
使用 Numpy
我們現在來看看第二項基準測試。它是快速排序演算法的實現。Julia 團隊使用了以下 Python 代碼：
def qsort_kernel(a, lo, hi):
i = lo
j = hi
while i < hi:
pivot = a[(lo+hi) // 2]
while i <= j:
while a[i] < pivot:
i += 1
while a[j] > pivot:
j -= 1
if i <= j:
a[i], a[j] = a[j], a[i]
i += 1
j -= 1
if lo < j:
qsort_kernel(a, lo, j)
lo = i
j = hi
return a

我將他們的基準測試代碼包裝在一個函數中：
import random
def benchmark_qsort():
lst = [ random.random() for i in range(1,5000) ]
qsort_kernel(lst, 0, len(lst)-1)

對它計時會得到：
100 loops, best of 3:18.3 ms per loop

上述代碼與 C 代碼非常相似。Cython 應該能很好地處理它。除了使用 Cython 和靜態類型之外，讓我們使用 Numpy
數組代替列表。在數組大小較大時，比如數千個或更多元素，Numpy 數組確實比
Python 列表更快。
安裝 Numpy 可能會花一些時間，推薦使用 Anaconda 或一個已安裝了 Python 科學工具組合的 Docker 鏡像。
在使用 Cython 時，需要將 Numpy 導入到應用了 Cython 的單元中。在使用 C 類型時，還必須使用 cimport 將它作為 C 模塊導入。Numpy
數組使用一種表示數組元素類型和數組維數（一維、二維等）的特殊語法來聲明。
%%cython
import numpy as np
cimport numpy as np
cpdef np.ndarray[double, ndim=1] \
qsort_kernel_cython_numpy_type(np.ndarray[double, ndim=1] a, \
long lo, \
long hi):
cdef:
long i, j
double pivot
i = lo
j = hi
while i < hi:
pivot = a[(lo+hi) // 2]
while i <= j:
while a[i] < pivot:
i += 1
while a[j] > pivot:
j -= 1
if i <= j:
a[i], a[j] = a[j], a[i]
i += 1
j -= 1
if lo < j:
qsort_kernel_cython_numpy_type(a, lo, j)
lo = i
j = hi
return a
cpdef benchmark_qsort_numpy_cython():
lst = np.random.rand(5000)
qsort_kernel_cython_numpy_type(lst, 0, len(lst)-1)

對 benchmark_qsort_numpy_cython() 函數計時會得到：
1000 loops, best of 3:1.32 ms per loop

我們比最初的基準測試快了約 15 倍，但這仍然不是使用 Python 的最佳方法。最佳方法是使用 Numpy 內置的 sort()
函數。它的默認行為是使用快速排序演算法。對此代碼計時：
def benchmark_sort_numpy():
lst = np.random.rand(5000)
np.sort(lst)

會得到：
1000 loops, best of 3:350 µs per loop

我們現在比最初的基準測試快 52 倍！Julia 在該基準測試上花費了 419 微秒，因此編譯的 Python 快 20%。
我知道，一些讀者會說我不會進行同類比較。我不同意。請記住，我們現在的任務是使用主機語言以最佳的方式排序輸入數組。在這種情況下，最佳方法是使用一個內置的函數。
http://www.ibm.com/developerworks/cn/opensource/os-make-python-faster-julia/

『肆』 如何理解Python裝飾器

理解Python中的裝飾器
@makebold
@makeitalic
def say():
return "Hello"

列印出如下的輸出：
<b><i>Hello<i></b>

你會怎麼做？最後給出的答案是：

def makebold(fn):
def wrapped():
return "<b>" + fn() + "</b>"
return wrapped

def makeitalic(fn):
def wrapped():
return "<i>" + fn() + "</i>"
return wrapped

@makebold
@makeitalic
def hello():
return "hello world"

print hello() ## 返回 <b><i>hello world</i></b>

現在我們來看看如何從一些最基礎的方式來理解Python的裝飾器。英文討論參考Here。
裝飾器是一個很著名的設計模式，經常被用於有切面需求的場景，較為經典的有插入日誌、性能測試、事務處理等。裝飾器是解決這類問題的絕佳設計，有了裝飾器，我們就可以抽離出大量函數中與函數功能本身無關的雷同代碼並繼續重用。概括的講，裝飾器的作用就是為已經存在的對象添加額外的功能。
1.1. 需求是怎麼來的？
裝飾器的定義很是抽象，我們來看一個小例子。

def foo():
print 'in foo()'
foo()

這是一個很無聊的函數沒錯。但是突然有一個更無聊的人，我們稱呼他為B君，說我想看看執行這個函數用了多長時間，好吧，那麼我們可以這樣做：

import time
def foo():
start = time.clock()
print 'in foo()'
end = time.clock()
print 'used:', end - start

foo()

很好，功能看起來無懈可擊。可是蛋疼的B君此刻突然不想看這個函數了，他對另一個叫foo2的函數產生了更濃厚的興趣。
怎麼辦呢？如果把以上新增加的代碼復制到foo2里，這就犯了大忌了~復制什麼的難道不是最討厭了么！而且，如果B君繼續看了其他的函數呢？
1.2. 以不變應萬變，是變也
還記得嗎，函數在Python中是一等公民，那麼我們可以考慮重新定義一個函數timeit，將foo的引用傳遞給他，然後在timeit中調用foo並進行計時，這樣，我們就達到了不改動foo定義的目的，而且，不論B君看了多少個函數，我們都不用去修改函數定義了！

import time

def foo():
print 'in foo()'

def timeit(func):
start = time.clock()
func()
end =time.clock()
print 'used:', end - start

timeit(foo)

看起來邏輯上並沒有問題，一切都很美好並且運作正常！……等等，我們似乎修改了調用部分的代碼。原本我們是這樣調用的：foo()，修改以後變成了：timeit(foo)。這樣的話，如果foo在N處都被調用了，你就不得不去修改這N處的代碼。或者更極端的，考慮其中某處調用的代碼無法修改這個情況，比如：這個函數是你交給別人使用的。
1.3. 最大限度地少改動！
既然如此，我們就來想想辦法不修改調用的代碼；如果不修改調用代碼，也就意味著調用foo()需要產生調用timeit(foo)的效果。我們可以想到將timeit賦值給foo，但是timeit似乎帶有一個參數……想辦法把參數統一吧！如果timeit(foo)不是直接產生調用效果，而是返回一個與foo參數列表一致的函數的話……就很好辦了，將timeit(foo)的返回值賦值給foo，然後，調用foo()的代碼完全不用修改！

#-*- coding: UTF-8 -*-
import time

def foo():
print 'in foo()'

# 定義一個計時器，傳入一個，並返回另一個附加了計時功能的方法
def timeit(func):

# 定義一個內嵌的包裝函數，給傳入的函數加上計時功能的包裝
def wrapper():
start = time.clock()
func()
end =time.clock()
print 'used:', end - start

# 將包裝後的函數返回
return wrapper

foo = timeit(foo)
foo()

這樣，一個簡易的計時器就做好了！我們只需要在定義foo以後調用foo之前，加上foo = timeit(foo)，就可以達到計時的目的，這也就是裝飾器的概念，看起來像是foo被timeit裝飾了。在在這個例子中，函數進入和退出時需要計時，這被稱為一個橫切面(Aspect)，這種編程方式被稱為面向切面的編程(Aspect-Oriented Programming)。與傳統編程習慣的從上往下執行方式相比較而言，像是在函數執行的流程中橫向地插入了一段邏輯。在特定的業務領域里，能減少大量重復代碼。面向切面編程還有相當多的術語，這里就不多做介紹，感興趣的話可以去找找相關的資料。
這個例子僅用於演示，並沒有考慮foo帶有參數和有返回值的情況，完善它的重任就交給你了 ：）
上面這段代碼看起來似乎已經不能再精簡了，Python於是提供了一個語法糖來降低字元輸入量。

import time

def timeit(func):
def wrapper():
start = time.clock()
func()
end =time.clock()
print 'used:', end - start
return wrapper

@timeit
def foo():
print 'in foo()'

foo()

重點關注第11行的@timeit，在定義上加上這一行與另外寫foo = timeit(foo)完全等價，千萬不要以為@有另外的魔力。除了字元輸入少了一些，還有一個額外的好處：這樣看上去更有裝飾器的感覺。
-------------------
要理解python的裝飾器，我們首先必須明白在Python中函數也是被視為對象。這一點很重要。先看一個例子：

def shout(word="yes") :
return word.capitalize()+" !"

print shout()
# 輸出 : 'Yes !'

# 作為一個對象，你可以把函數賦給任何其他對象變數

scream = shout

# 注意我們沒有使用圓括弧，因為我們不是在調用函數
# 我們把函數shout賦給scream，也就是說你可以通過scream調用shout

print scream()
# 輸出 : 'Yes !'

# 還有，你可以刪除舊的名字shout，但是你仍然可以通過scream來訪問該函數

del shout
try :
print shout()
except NameError, e :
print e
#輸出 : "name 'shout' is not defined"

print scream()
# 輸出 : 'Yes !'

我們暫且把這個話題放旁邊，我們先看看python另外一個很有意思的屬性：可以在函數中定義函數：

def talk() :

# 你可以在talk中定義另外一個函數
def whisper(word="yes") :
return word.lower()+"...";

# ... 並且立馬使用它

print whisper()

# 你每次調用'talk'，定義在talk裡面的whisper同樣也會被調用
talk()
# 輸出 :
# yes...

# 但是"whisper" 不會單獨存在:

try :
print whisper()
except NameError, e :
print e
#輸出 : "name 'whisper' is not defined"*

函數引用
從以上兩個例子我們可以得出，函數既然作為一個對象，因此：
1. 其可以被賦給其他變數
2. 其可以被定義在另外一個函數內
這也就是說，函數可以返回一個函數，看下面的例子：

def getTalk(type="shout") :

# 我們定義另外一個函數
def shout(word="yes") :
return word.capitalize()+" !"

def whisper(word="yes") :
return word.lower()+"...";

# 然後我們返回其中一個
if type == "shout" :
# 我們沒有使用(),因為我們不是在調用該函數
# 我們是在返回該函數
return shout
else :
return whisper

# 然後怎麼使用呢 ?

# 把該函數賦予某個變數
talk = getTalk()

# 這里你可以看到talk其實是一個函數對象:
print talk
#輸出 : <function shout at 0xb7ea817c>

# 該對象由函數返回的其中一個對象:
print talk()

# 或者你可以直接如下調用 :
print getTalk("whisper")()
#輸出 : yes...

還有，既然可以返回一個函數，我們可以把它作為參數傳遞給函數：

def doSomethingBefore(func) :
print "I do something before then I call the function you gave me"
print func()

doSomethingBefore(scream)
#輸出 :
#I do something before then I call the function you gave me
#Yes !

這里你已經足夠能理解裝飾器了，其他它可被視為封裝器。也就是說，它能夠讓你在裝飾前後執行代碼而無須改變函數本身內容。
手工裝飾
那麼如何進行手動裝飾呢？

# 裝飾器是一個函數，而其參數為另外一個函數
def my_shiny_new_decorator(a_function_to_decorate) :

# 在內部定義了另外一個函數：一個封裝器。
# 這個函數將原始函數進行封裝，所以你可以在它之前或者之後執行一些代碼
def the_wrapper_around_the_original_function() :

# 放一些你希望在真正函數執行前的一些代碼
print "Before the function runs"

# 執行原始函數
a_function_to_decorate()

# 放一些你希望在原始函數執行後的一些代碼
print "After the function runs"

#在此刻，"a_function_to_decrorate"還沒有被執行，我們返回了創建的封裝函數
#封裝器包含了函數以及其前後執行的代碼，其已經准備完畢
return the_wrapper_around_the_original_function

# 現在想像下，你創建了一個你永遠也不遠再次接觸的函數
def a_stand_alone_function() :
print "I am a stand alone function, don't you dare modify me"

a_stand_alone_function()
#輸出: I am a stand alone function, don't you dare modify me

# 好了，你可以封裝它實現行為的擴展。可以簡單的把它丟給裝飾器
# 裝飾器將動態地把它和你要的代碼封裝起來，並且返回一個新的可用的函數。
a_stand_alone_function_decorated = my_shiny_new_decorator(a_stand_alone_function)
a_stand_alone_function_decorated()
#輸出 :
#Before the function runs
#I am a stand alone function, don't you dare modify me
#After the function runs

現在你也許要求當每次調用a_stand_alone_function時，實際調用卻是a_stand_alone_function_decorated。實現也很簡單，可以用my_shiny_new_decorator來給a_stand_alone_function重新賦值。

a_stand_alone_function = my_shiny_new_decorator(a_stand_alone_function)
a_stand_alone_function()
#輸出 :
#Before the function runs
#I am a stand alone function, don't you dare modify me
#After the function runs

# And guess what, that's EXACTLY what decorators do !

裝飾器揭秘
前面的例子，我們可以使用裝飾器的語法：

@my_shiny_new_decorator
def another_stand_alone_function() :
print "Leave me alone"

another_stand_alone_function()
#輸出 :
#Before the function runs
#Leave me alone
#After the function runs

當然你也可以累積裝飾：

def bread(func) :
def wrapper() :
print "</''''''\>"
func()
print "<\______/>"
return wrapper

def ingredients(func) :
def wrapper() :
print "#tomatoes#"
func()
print "~salad~"
return wrapper

def sandwich(food="--ham--") :
print food

sandwich()
#輸出 : --ham--
sandwich = bread(ingredients(sandwich))
sandwich()
#outputs :
#</''''''\>
# #tomatoes#
# --ham--
# ~salad~
#<\______/>

使用python裝飾器語法：

@bread
@ingredients
def sandwich(food="--ham--") :
print food

sandwich()
#輸出 :
#</''''''\>
# #tomatoes#
# --ham--
# ~salad~
#<\______/>

『伍』 python timeit 性能測試默認執行多少次

方法：
timeit(number=1000000)
計時主要語句執行number次的時間。它將執行一次setup語句，返回執行主要語句執行多次所需的時間，以浮點數秒數表示。參數為循環的次數，默認是100萬。要用的主語句、setup語句和計時器函數將傳遞給構造函數。

『陸』 python 列印出函數執行所用時間

使用timeit模塊，先介紹下：

timeit 模塊

timeit模塊定義了接受兩個參數的Timer類。兩個參數都是字元串。 第一個參數是你要計時的語句或者函數。 傳遞給Timer的第二個參數是為第一個參數語句構建環境的導入語句。 從內部講，timeit構建起一個獨立的虛擬環境， 手工地執行建立語句，然後手工地編譯和執行被計時語句。

一旦有了Timer對象，最簡單的事就是調用timeit()，它接受一個參數為每個測試中調用被計時語句的次數，默認為一百萬次；返回所耗費的秒數。

Timer對象的另一個主要方法是repeat()， 它接受兩個可選參數。 第一個參數是重復整個測試的次數，第二個參數是每個測試中調用被計時語句的次數。 兩個參數都是可選的，它們的默認值分別是3和1000000。repeat()方法返回以秒記錄的每個測試循環的耗時列表。Python有一個方便的min函數可以把輸入的列表返回成最小值，如： min(t.repeat(3, 1000000))

你可以在命令行使用timeit模塊來測試一個已存在的Python程序，而不需要修改代碼。

再給你個例子，你就知道怎麼做了。

#-*-coding:utf-8-*-
#!/bin/envpython

deftest1():
n=0
foriinrange(101):
n+=i
returnn

deftest2():
returnsum(range(101))

deftest3():
returnsum(xforxinrange(101))

if__name__=='__main__':
fromtimeitimportTimer
t1=Timer("test1()","from__main__importtest1")
t2=Timer("test2()","from__main__importtest2")
t3=Timer("test3()","from__main__importtest3")
printt1.timeit(1000000)
printt2.timeit(1000000)
printt3.timeit(1000000)
printt1.repeat(3,1000000)
printt2.repeat(3,1000000)
printt3.repeat(3,1000000)

『柒』 python timeit怎麼用

python timeit 是 Python 的標准庫；

This mole provides a simple way to time small bits of Python code.

先看一個例子吧：

importtimeit
#執行命令
t2=timeit.Timer('x=range(1000)')
#顯示時間
t2.timeit()
#10.620039563513103

#執行命令
t1=timeit.Timer('sum(x)','x=(iforiinrange(1000))')
#顯示時間
t1.timeit()
#0.1881566039438201

更詳細的示例和信息可以參考 Python 官方文檔：

https://docs.python.org/2/library/timeit.html

『捌』 如何使用python timeit模塊使用實踐

其實平時使用測試應用運行時間的情況 細算一下還真的很少。很久沒有做性能優化的工作，不管是cProfile還是timeit模塊都已經生疏了很久沒有使用，我在以前的文章裡面有提到過cPfile的性能測試使用，但是一直沒有使用過這個更輕量級的運行時間測量庫進行過仔細實踐總結，今天就來總結一下。

從最簡單的例子開始，比如我們想測試一個列表推導式究竟要比正常寫for快多少。