用python實現(xiàn)計時器功能，代碼如下：
創(chuàng)新互聯(lián)公司是專業(yè)的普洱網站建設公司，普洱接單;提供網站制作、成都網站設計,網頁設計,網站設計,建網站,PHP網站建設等專業(yè)做網站服務;采用PHP框架,可快速的進行普洱網站開發(fā)網頁制作和功能擴展;專業(yè)做搜索引擎喜愛的網站,專業(yè)的做網站團隊,希望更多企業(yè)前來合作!
''' Simple Timing Function.
This function prints out a message with the elapsed time from the
previous call. It works with most Python 2.x platforms. The function
uses a simple trick to store a persistent variable (clock) without
using a global variable.
'''
import time
def dur( op=None, clock=[time.time()] ):
if op != None:
duration = time.time() - clock[0]
print '%s finished. Duration %.6f seconds.' % (op, duration)
clock[0] = time.time()
# Example
if __name__ == '__main__':
import array
dur() # Initialise the timing clock
opt1 = array.array('H')
for i in range(1000):
for n in range(1000):
opt1.append(n)
dur('Array from append')
opt2 = array.array('H')
seq = range(1000)
for i in range(1000):
opt2.extend(seq)
dur('Array from list extend')
opt3 = array.array('H')
seq = array.array('H', range(1000))
for i in range(1000):
opt3.extend(seq)
dur('Array from array extend')
# Output:
# Array from append finished. Duration 0.175320 seconds.
# Array from list extend finished. Duration 0.068974 seconds.
# Array from array extend finished. Duration 0.001394 seconds.
單元測試（Unit Testing）
為程序編寫測試——如果做的到位——有助于減少bug的出現(xiàn)，并可以提高我們對程序按預期目標運行的信心。通常，測試并不能保證正確性，因為對大多數程序而言， 可能的輸入范圍以及可能的計算范圍是如此之大，只有其中最小的一部分能被實際地進 行測試。盡管如此，通過仔細地選擇測試的方法和目標，可以提高代碼的質量。
大量不同類型的測試都可以進行，比如可用性測試、功能測試以及整合測試等。這里, 我們只講單元測試一對單獨的函數、類與方法進行測試，確保其符合預期的行為。
TDD的一個關鍵點是，當我們想添加一個功能時——比如為類添加一個方法—— 我們首次為其編寫一個測試用例。當然，測試將失敗，因為我們還沒有實際編寫該方法?，F(xiàn)在，我們編寫該方法，一旦方法通過了測試，就可以返回所有測試，確保我們新添加的代碼沒有任何預期外的副作用。一旦所有測試運行完畢（包括我們?yōu)樾鹿δ芫帉懙臏y試），就可以對我們的代碼進行檢查，并有理有據地相信程序行為符合我們的期望——當然，前提是我們的測試是適當的。
比如，我們編寫了一個函數，該函數在特定的索引位置插入一個字符串，可以像下面這樣開始我們的TDD：
def insert_at（string, position, insert）:
"""Returns a copy of string with insert inserted at the position
string = "ABCDE"
result =[]
for i in range(-2, len(string) + 2):
... result.append(insert_at(string, i,“-”))
result[:5]
['ABC-DE', 'ABCD-E', '-ABCDE','A-BCDE', 'AB-CDE']
result[5:]
['ABC-DE', 'ABCD-E', 'ABCDE-', 'ABCDE-']
"""
return string
對不返回任何參數的函數或方法（通常返回None）,我們通常賦予其由pass構成的一個suite,對那些返回值被試用的，我們或者返回一個常數（比如0）,或者某個不變的參數——這也是我們這里所做的。（在更復雜的情況下，返回fake對象可能更有用一一對這樣的類，提供mock對象的第三方模塊是可用的。）
運行doctest時會失敗，并列出每個預期內的字符串（'ABCD-EF'、'ABCDE-F' 等），及其實際獲取的字符串（所有的都是'ABCD-EF'）。一旦確定doctest是充分的和正確的，就可以編寫該函數的主體部分，在本例中只是簡單的return string[:position] + insert+string[position:]。（如果我們編寫的是 return string[:position] + insert,之后復制 string [:position]并將其粘貼在末尾以便減少一些輸入操作，那么doctest會立即提示錯誤。）
Python的標準庫提供了兩個單元測試模塊，一個是doctest,這里和前面都簡單地提到過，另一個是unittest。此外，還有一些可用于Python的第三方測試工具。其中最著名的兩個是nose (code.google.com/p/python-nose)與py.test (codespeak.net/py/dist/test/test.html), nose 致力于提供比標準的unittest 模塊更廣泛的功能，同時保持與該模塊的兼容性，py.test則采用了與unittest有些不同的方法，試圖盡可能消除樣板測試代碼。這兩個第三方模塊都支持測試發(fā)現(xiàn)，因此沒必要寫一個總體的測試程序——因為模塊將自己搜索測試程序。這使得測試整個代碼樹或某一部分 (比如那些已經起作用的模塊)變得很容易。那些對測試嚴重關切的人，在決定使用哪個測試工具之前，對這兩個(以及任何其他有吸引力的)第三方模塊進行研究都是值 得的。
創(chuàng)建doctest是直截了當的：我們在模塊中編寫測試、函數、類與方法的docstrings。 對于模塊，我們簡單地在末尾添加了 3行：
if __name__ =="__main__":
import doctest
doctest.testmod()
在程序內部使用doctest也是可能的。比如，blocks.py程序(其模塊在后面)有自己函數的doctest，但以如下代碼結尾：
if __name__== "__main__":
main()
這里簡單地調用了程序的main()函數，并且沒有執(zhí)行程序的doctest。要實驗程序的 doctest,有兩種方法。一種是導入doctest模塊，之后運行程序---比如，在控制臺中輸 入 python3 -m doctest blocks.py (在 Wndows 平臺上，使用類似于 C:Python3 lpython.exe 這樣的形式替代python3)。如果所有測試運行良好，就沒有輸出，因此，我們可能寧愿執(zhí)行python3-m doctest blocks.py-v,因為這會列出每個執(zhí)行的doctest,并在最后給出結果摘要。
另一種執(zhí)行doctest的方法是使用unittest模塊創(chuàng)建單獨的測試程序。在概念上， unittest模塊是根據Java的JUnit單元測試庫進行建模的，并用于創(chuàng)建包含測試用例的測試套件。unittest模塊可以基于doctests創(chuàng)建測試用例，而不需要知道程序或模塊包含的任何事物——只要知道其包含doctest即可。因此，為給blocks.py程序制作一個測試套件，我們可以創(chuàng)建如下的簡單程序(將其稱為test_blocks.py)：
import doctest
import unittest
import blocks
suite = unittest.TestSuite()
suite.addTest(doctest.DocTestSuite(blocks))
runner = unittest.TextTestRunner()
print(runner.run(suite))
注意，如果釆用這種方法，程序的名稱上會有一個隱含的約束：程序名必須是有效的模塊名。因此，名為convert-incidents.py的程序的測試不能寫成這樣。因為import convert-incidents不是有效的，在Python標識符中，連接符是無效的（避開這一約束是可能的，但最簡單的解決方案是使用總是有效模塊名的程序文件名，比如，使用下劃線替換連接符）。這里展示的結構（創(chuàng)建一個測試套件，添加一個或多個測試用例或測試套件，運行總體的測試套件，輸出結果）是典型的機遇unittest的測試。運行時，這一特定實例產生如下結果：
...
.............................................................................................................
Ran 3 tests in 0.244s
OK
每次執(zhí)行一個測試用例時，都會輸出一個句點（因此上面的輸出最前面有3個句點），之后是一行連接符，再之后是測試摘要（如果有任何一個測試失敗，就會有更多的輸出信息）。
如果我們嘗試將測試分離開（典型情況下是要測試的每個程序和模塊都有一個測試用例），就不要再使用doctests,而是直接使用unittest模塊的功能——尤其是我們習慣于使用JUnit方法進行測試時ounittest模塊會將測試分離于代碼——對大型項目（測試編寫人員與開發(fā)人員可能不一致）而言，這種方法特別有用。此外，unittest單元測試編寫為獨立的Python模塊，因此，不會像在docstring內部編寫測試用例時受到兼容性和明智性的限制。
unittest模塊定義了 4個關鍵概念。測試夾具是一個用于描述創(chuàng)建測試（以及用完之后將其清理）所必需的代碼的術語，典型實例是創(chuàng)建測試所用的一個輸入文件，最后刪除輸入文件與結果輸出文件。測試套件是一組測試用例的組合。測試用例是測試的基本單元—我們很快就會看到實例。測試運行者是執(zhí)行一個或多個測試套件的對象。
典型情況下，測試套件是通過創(chuàng)建unittest.TestCase的子類實現(xiàn)的，其中每個名稱 以“test”開頭的方法都是一個測試用例。如果我們需要完成任何創(chuàng)建操作，就可以在一個名為setUp()的方法中實現(xiàn)；類似地，對任何清理操作，也可以實現(xiàn)一個名為 tearDown()的方法。在測試內部，有大量可供我們使用的unittest.TestCase方法，包括 assertTrue()、assertEqual()、assertAlmostEqual()（對于測試浮點數很有用）、assertRaises() 以及更多，還包括很多對應的逆方法，比如assertFalse()、assertNotEqual()、failIfEqual()、 failUnlessEqual ()等。
unittest模塊進行了很好的歸檔，并且提供了大量功能，但在這里我們只是通過一 個非常簡單的測試套件來感受一下該模塊的使用。這里將要使用的實例,該練習要求創(chuàng)建一個Atomic模塊，該模塊可以用作一 個上下文管理器，以確保或者所有改變都應用于某個列表、集合或字典，或者所有改變都不應用。作為解決方案提供的Atomic.py模塊使用30行代碼來實現(xiàn)Atomic類， 并提供了 100行左右的模塊doctest。這里，我們將創(chuàng)建test_Atomic.py模塊，并使用 unittest測試替換doctest,以便可以刪除doctest。
在編寫測試模塊之前，我們需要思考都需要哪些測試。我們需要測試3種不同的數據類型：列表、集合與字典。對于列表，需要測試的是插入項、刪除項或修改項的值。對于集合，我們必須測試向其中添加或刪除一個項。對于字典，我們必須測試的是插入一個項、修改一個項的值、刪除一個項。此外，還必須要測試的是在失敗的情況下，不會有任何改變實際生效。
結構上看，測試不同數據類型實質上是一樣的，因此，我們將只為測試列表編寫測試用例，而將其他的留作練習。test_Atomic.py模塊必須導入unittest模塊與要進行測試的Atomic模塊。
創(chuàng)建unittest文件時，我們通常創(chuàng)建的是模塊而非程序。在每個模塊內部，我們定義一個或多個unittest.TestCase子類。比如，test_Atomic.py模塊中僅一個單獨的 unittest-TestCase子類，也就是TestAtomic (稍后將對其進行講解)，并以如下兩行結束:
if name == "__main__":
unittest.main()
這兩行使得該模塊可以單獨運行。當然，該模塊也可以被導入并從其他測試程序中運行——如果這只是多個測試套件中的一個，這一點是有意義的。
如果想要從其他測試程序中運行test_Atomic.py模塊，那么可以編寫一個與此類似的程序。我們習慣于使用unittest模塊執(zhí)行doctests,比如：
import unittest
import test_Atomic
suite = unittest.TestLoader().loadTestsFromTestCase(test_Atomic.TestAtomic)
runner = unittest.TextTestRunner()
pnnt(runner.run(suite))
這里，我們已經創(chuàng)建了一個單獨的套件，這是通過讓unittest模塊讀取test_Atomic 模塊實現(xiàn)的，并且使用其每一個test*()方法(本實例中是test_list_success()、test_list_fail()，稍后很快就會看到)作為測試用例。
我們現(xiàn)在將查看TestAtomic類的實現(xiàn)。對通常的子類(不包括unittest.TestCase 子類)，不怎么常見的是，沒有必要實現(xiàn)初始化程序。在這一案例中，我們將需要建立 一個方法，但不需要清理方法，并且我們將實現(xiàn)兩個測試用例。
def setUp(self)：
self.original_list = list(range(10))
我們已經使用了 unittest.TestCase.setUp()方法來創(chuàng)建單獨的測試數據片段。
def test_list_succeed(self):
items = self.original_list[:]
with Atomic.Atomic(items) as atomic:
atomic.append(1999)
atomic.insert(2, -915)
del atomic[5]
atomic[4]= -782
atomic.insert(0, -9)
self.assertEqual(items,
[-9, 0, 1, -915, 2, -782, 5, 6, 7, 8, 9, 1999])
def test_list_fail(self):
items = self.original_list[:]
with self.assertRaises(AttributeError):
with Atomic.Atomic(items) as atomic:
atomic.append(1999)
atomic.insert(2, -915)
del atomic[5]
atomic[4] = -782
atomic.poop() # Typo
self.assertListEqual(items, self.original_list)
這里，我們直接在測試方法中編寫了測試代碼，而不需要一個內部函數，也不再使用unittest.TestCase.assertRaised()作為上下文管理器(期望代碼產生AttributeError)。 最后我們也使用了 Python 3.1 的 unittest.TestCase.assertListEqual()方法。
正如我們已經看到的，Python的測試模塊易于使用，并且極為有用，在我們使用 TDD的情況下更是如此。它們還有比這里展示的要多得多的大量功能與特征——比如，跳過測試的能力，這有助于理解平臺差別——并且這些都有很好的文檔支持。缺失的一個功能——但nose與py.test提供了——是測試發(fā)現(xiàn)，盡管這一特征被期望在后續(xù)的Python版本(或許與Python 3.2—起)中出現(xiàn)。
性能剖析（Profiling）
如果程序運行很慢，或者消耗了比預期內要多得多的內存，那么問題通常是選擇的算法或數據結構不合適，或者是以低效的方式進行實現(xiàn)。不管問題的原因是什么， 最好的方法都是準確地找到問題發(fā)生的地方,而不只是檢査代碼并試圖對其進行優(yōu)化。 隨機優(yōu)化會導致引入bug,或者對程序中本來對程序整體性能并沒有實際影響的部分進行提速，而這并非解釋器耗費大部分時間的地方。
在深入討論profiling之前，注意一些易于學習和使用的Python程序設計習慣是有意義的，并且對提高程序性能不無裨益。這些技術都不是特定于某個Python版本的， 而是合理的Python程序設計風格。第一，在需要只讀序列時，最好使用元組而非列表； 第二，使用生成器，而不是創(chuàng)建大的元組和列表并在其上進行迭代處理；第三，盡量使用Python內置的數據結構 dicts、lists、tuples 而不實現(xiàn)自己的自定義結構，因為內置的數據結構都是經過了高度優(yōu)化的；第四，從小字符串中產生大字符串時， 不要對小字符串進行連接，而是在列表中累積，最后將字符串列表結合成為一個單獨的字符串；第五，也是最后一點，如果某個對象(包括函數或方法)需要多次使用屬性進行訪問(比如訪問模塊中的某個函數)，或從某個數據結構中進行訪問，那么較好的做法是創(chuàng)建并使用一個局部變量來訪問該對象，以便提供更快的訪問速度。
Python標準庫提供了兩個特別有用的模塊，可以輔助調査代碼的性能問題。一個是timeit模塊——該模塊可用于對一小段Python代碼進行計時，并可用于諸如對兩個或多個特定函數或方法的性能進行比較等場合。另一個是cProfile模塊，可用于profile 程序的性能——該模塊對調用計數與次數進行了詳細分解，以便發(fā)現(xiàn)性能瓶頸所在。
為了解timeit模塊，我們將查看一些小實例。假定有3個函數function_a()、 function_b()、function_c(), 3個函數執(zhí)行同樣的計算，但分別使用不同的算法。如果將這些函數放于同一個模塊中(或分別導入)，就可以使用timeit模塊對其進行運行和比較。下面給出的是模塊最后使用的代碼：
if __name__ == "__main__":
repeats = 1000
for function in ("function_a", "function_b", "function_c"):
t = timeit.Timer("{0}(X, Y)".format(function),"from __main__ import {0}, X, Y".format(function))
sec = t.timeit(repeats) / repeats
print("{function}() {sec:.6f} sec".format(**locals()))
賦予timeit.Timer()構造子的第一個參數是我們想要執(zhí)行并計時的代碼，其形式是字符串。這里，該字符串是“function_a(X,Y)”；第二個參數是可選的，還是一個待執(zhí)行的字符串，這一次是在待計時的代碼之前，以便提供一些建立工作。這里，我們從 __main__ (即this)模塊導入了待測試的函數，還有兩個作為輸入數據傳入的變量(X 與Y),這兩個變量在該模塊中是作為全局變量提供的。我們也可以很輕易地像從其他模塊中導入數據一樣來進行導入操作。
調用timeit.Timer對象的timeit()方法時，首先將執(zhí)行構造子的第二個參數(如果有)， 之后執(zhí)行構造子的第一個參數并對其執(zhí)行時間進行計時。timeit.Timer.timeit()方法的返回值是以秒計數的時間，類型是float。默認情況下，timeit()方法重復100萬次，并返回所 有這些執(zhí)行的總秒數，但在這一特定案例中，只需要1000次反復就可以給出有用的結果, 因此對重復計數次數進行了顯式指定。在對每個函數進行計時后，使用重復次數對總數進行除法操作，就得到了平均執(zhí)行時間，并在控制臺中打印出函數名與執(zhí)行時間。
function_a() 0.001618 sec
function_b() 0.012786 sec
function_c() 0.003248 sec
在這一實例中，function_a()顯然是最快的——至少對于這里使用的輸入數據而言。 在有些情況下一一比如輸入數據不同會對性能產生巨大影響——可能需要使用多組輸入數據對每個函數進行測試，以便覆蓋有代表性的測試用例，并對總執(zhí)行時間或平均執(zhí)行時間進行比較。
有時監(jiān)控自己的代碼進行計時并不是很方便，因此timeit模塊提供了一種在命令行中對代碼執(zhí)行時間進行計時的途徑。比如，要對MyModule.py模塊中的函數function_a()進行計時，可以在控制臺中輸入如下命令：python3 -m timeit -n 1000 -s "from MyModule import function_a, X, Y" "function_a(X, Y)"(與通常所做的一樣，對 Windows 環(huán)境，我們必須使用類似于C:Python3lpython.exe這樣的內容來替換python3)。-m選項用于Python 解釋器，使其可以加載指定的模塊(這里是timeit),其他選項則由timeit模塊進行處理。 -n選項指定了循環(huán)計數次數，-s選項指定了要建立，最后一個參數是要執(zhí)行和計時的代碼。命令完成后，會向控制臺中打印運行結果，比如：
1000 loops, best of 3: 1.41 msec per loop
之后我們可以輕易地對其他兩個函數進行計時，以便對其進行整體的比較。
cProfile模塊(或者profile模塊，這里統(tǒng)稱為cProfile模塊)也可以用于比較函數 與方法的性能。與只是提供原始計時的timeit模塊不同的是，cProfile模塊精確地展示 了有什么被調用以及每個調用耗費了多少時間。下面是用于比較與前面一樣的3個函數的代碼：
if __name__ == "__main__":
for function in ("function_a", "function_b", "function_c"):
cProfile.run("for i in ranged 1000): {0}(X, Y)".format(function))
我們必須將重復的次數放置在要傳遞給cProfile.run()函數的代碼內部，但不需要做任何創(chuàng)建，因為模塊函數會使用內省來尋找需要使用的函數與變量。這里沒有使用顯式的print()語句，因為默認情況下，cProfile.run()函數會在控制臺中打印其輸出。下面給出的是所有函數的相關結果(有些無關行被省略，格式也進行了稍許調整，以便與頁面適應)：
1003 function calls in 1.661 CPU seconds
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.003 0.003 1.661 1.661 :1 ( )
1000 1.658 0.002 1.658 0.002 MyModule.py:21 (function_a)
1 0.000 0.000 1.661 1.661 {built-in method exec}
5132003 function calls in 22.700 CPU seconds
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.487 0.487 22.700 22.700 : 1 ( )
1000 0.011 0.000 22.213 0.022 MyModule.py:28(function_b)
5128000 7.048 0.000 7.048 0.000 MyModule.py:29( )
1000 0.00 50.000 0.005 0.000 {built-in method bisectjeft}
1 0.000 0.000 22.700 22.700 {built-in method exec}
1000 0.001 0.000 0.001 0.000 {built-in method len}
1000 15.149 0.015 22.196 0.022 {built-in method sorted}
5129003 function calls in 12.987 CPU seconds
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.205 0.205 12.987 12.987 :l ( )
1000 6.472 0.006 12.782 0.013 MyModule.py:36(function_c)
5128000 6.311 0.000 6.311 0.000 MyModule.py:37( )
1 0.000 0.000 12.987 12.987 {built-in method exec}
ncalls ("調用的次數")列列出了對指定函數(在filename:lineno(function)中列出) 的調用次數。回想一下我們重復了 1000次調用，因此必須將這個次數記住。tottime (“總的時間”)列列出了某個函數中耗費的總時間，但是排除了函數調用的其他函數內部花費的時間。第一個percall列列出了對函數的每次調用的平均時間(tottime // ncalls)。 cumtime ("累積時間")列出了在函數中耗費的時間，并且包含了函數調用的其他函數內部花費的時間。第二個percall列列出了對函數的每次調用的平均時間，包括其調用的函數耗費的時間。
這種輸出信息要比timeit模塊的原始計時信息富有啟發(fā)意義的多。我們立即可以發(fā)現(xiàn)，function_b()與function_c()使用了被調用5000次以上的生成器，使得它們的速度至少要比function_a()慢10倍以上。并且，function_b()調用了更多通常意義上的函數，包括調用內置的sorted()函數，這使得其幾乎比function_c()還要慢兩倍。當然,timeit() 模塊提供了足夠的信息來查看計時上存在的這些差別，但cProfile模塊允許我們了解為什么會存在這些差別。正如timeit模塊允許對代碼進行計時而又不需要對其監(jiān)控一樣，cProfile模塊也可以做到這一點。然而，從命令行使用cProfile模塊時，我們不能精確地指定要執(zhí)行的 是什么——而只是執(zhí)行給定的程序或模塊，并報告所有這些的計時結果。需要使用的 命令行是python3 -m cProfile programOrModule.py,產生的輸出信息與前面看到的一 樣，下面給出的是輸出信息樣例，格式上進行了一些調整，并忽略了大多數行：
10272458 function calls (10272457 primitive calls) in 37.718 CPU secs
ncalls tottime percall cumtime percall filename:lineno(function)
10.000 0.000 37.718 37.718 :1 ( )
10.719 0.719 37.717 37.717 :12( )
1000 1.569 0.002 1.569 0.002 :20(function_a)
1000 0.011 0.000 22.560 0.023 :27(function_b)
5128000 7.078 0.000 7.078 0.000 :28( )
1000 6.510 0.007 12.825 0.013 :35(function_c)
5128000 6.316 0.000 6.316 0.000 :36( )
在cProfile術語學中，原始調用指的就是非遞歸的函數調用。
以這種方式使用cProfile模塊對于識別值得進一步研究的區(qū)域是有用的。比如，這里 我們可以清晰地看到function_b()需要耗費更長的時間，但是我們怎樣獲取進一步的詳細資料？我們可以使用cProfile.run("function_b()")來替換對function_b()的調用。或者可以保存完全的profile數據并使用pstats模塊對其進行分析。要保存profile,就必須對命令行進行稍許修改:python3 -m cProfile -o profileDataFile programOrModule.py。 之后可以對 profile 數據進行分析，比如啟動IDLE,導入pstats模塊，賦予其已保存的profileDataFile,或者也可以在控制臺中交互式地使用pstats。
下面給出的是一個非常短的控制臺會話實例，為使其適合頁面展示，進行了適當調整，我們自己的輸入則以粗體展示：
$ python3 -m cProfile -o profile.dat MyModule.py
$ python3 -m pstats
Welcome to the profile statistics browser.
% read profile.dat
profile.dat% callers function_b
Random listing order was used
List reduced from 44 to 1 due to restriction
Function was called by...
ncalls tottime cumtime
:27(function_b) - 1000 0.011 22.251 :12( )
profile.dat% callees function_b
Random listing order was used
List reduced from 44 to 1 due to restriction
Function called...
ncalls tottime cumtime
:27(function_b)-
1000 0.005 0.005 built-in method bisectJeft
1000 0.001 0.001 built-in method len
1000 1 5.297 22.234 built-in method sorted
profile.dat% quit
輸入help可以獲取命令列表，help后面跟隨命令名可以獲取該命令的更多信息。比如, help stats將列出可以賦予stats命令的參數。還有其他一些可用的工具，可以提供profile數據的圖形化展示形式，比如 RunSnakeRun (), 該工具需要依賴于wxPython GUI庫。
使用timeit與cProfile模塊，我們可以識別出我們自己代碼中哪些區(qū)域會耗費超過預期的時間；使用cProfile模塊，還可以準確算岀時間消耗在哪里。
以上內容部分摘自視頻課程 05后端編程Python-19調試、測試和性能調優(yōu)(下) ，更多實操示例請參照視頻講解。跟著張員外講編程，學習更輕松，不花錢還能學習真本領。
定義在默認的計時器中，針對不同平臺采用不同方式。在Windows上，time.clock()具有微秒精度，但是time.time()精度是1/60s。在Unix上，time.clock()有1/100s精度，而且time.time()精度遠遠更高。在另外的平臺上，default_timer()測量的是墻上時鐘時間，不是CPU時間。這意味著同一計算機的其他進程可能影響計時
版權聲明：
def clock(func):
def clocked(*args, **kwargs):
t0 = timeit.default_timer()
result = func(*args, **kwargs)
elapsed = timeit.default_timer()?- t0
name = func.__name__
arg_str = ', '.join(repr(arg) for arg in args)
print('[%0.8fs] %s(%s) - %r' % (elapsed, name, arg_str, result))
return result
return clocked
@clock
def run(seconds):
time.sleep(seconds)
return time
if __name__ == '__main__':
run(1)
本文為CSDN博主「FlyingPie」的原創(chuàng)文章，遵循CC 4.0 BY-SA版權協(xié)議，附上原文出處鏈接及聲明。
原文鏈接：
參考資料：CSDN。
數學相關
abs(a) : 求取絕對值。abs(-1)
max(list) : 求取list最大值。max([1,2,3])
min(list) : 求取list最小值。min([1,2,3])
sum(list) : 求取list元素的和。 sum([1,2,3]) 6
sorted(list) : 排序，返回排序后的list。
len(list) : list長度,len([1,2,3])
divmod(a,b): 獲取商和余數。 divmod(5,2) (2,1)
pow(a,b) : 獲取乘方數。pow(2,3) 8
round(a,b) : 獲取指定位數的小數。a代表浮點數，b代表要保留的位數。round(3.1415926,2) 3.14
range(a[,b]) : 生成一個a到b的數組,左閉右開。range(1,10) [1,2,3,4,5,6,7,8,9]
類型轉換
int(str) : 轉換為int型。int('1') 1
float(int/str) : 將int型或字符型轉換為浮點型。float('1') 1.0
str(int) : 轉換為字符型。str(1) '1'
bool(int) : 轉換為布爾類型。 str(0) False str(None) False
bytes(str,code) : 接收一個字符串，與所要編碼的格式，返回一個字節(jié)流類型。bytes('abc', 'utf-8') b'abc' bytes(u'爬蟲', 'utf-8') b'xe7x88xacxe8x99xab'
list(iterable) : 轉換為list。 list((1,2,3)) [1,2,3]
iter(iterable)： 返回一個可迭代的對象。 iter([1,2,3]) list_iterator object at 0x0000000003813B00
dict(iterable) : 轉換為dict。 dict([('a', 1), ('b', 2), ('c', 3)]) {'a':1, 'b':2, 'c':3}
enumerate(iterable) : 返回一個枚舉對象。
tuple(iterable) : 轉換為tuple。 tuple([1,2,3]) (1,2,3)
set(iterable) : 轉換為set。 set([1,4,2,4,3,5]) {1,2,3,4,5} set({1:'a',2:'b',3:'c'}) {1,2,3}
hex(int) : 轉換為16進制。hex(1024) '0x400'
oct(int) : 轉換為8進制。 oct(1024) '0o2000'
bin(int) : 轉換為2進制。 bin(1024) '0b10000000000'
chr(int) : 轉換數字為相應ASCI碼字符。 chr(65) 'A'
ord(str) : 轉換ASCI字符為相應的數字。 ord('A') 65
相關操作
eval****() : 執(zhí)行一個表達式，或字符串作為運算。 eval('1+1') 2
exec() : 執(zhí)行python語句。 exec('print("Python")') Python
filter(func, iterable) : 通過判斷函數fun，篩選符合條件的元素。 filter(lambda x: x3, [1,2,3,4,5,6]) filter object at 0x0000000003813828
map(func, *iterable) : 將func用于每個iterable對象。 map(lambda a,b: a+b, [1,2,3,4], [5,6,7]) [6,8,10]
zip(*iterable) : 將iterable分組合并。返回一個zip對象。 list(zip([1,2,3],[4,5,6])) [(1, 4), (2, 5), (3, 6)]
type()：返回一個對象的類型。
id()： 返回一個對象的唯一標識值。
hash(object)：返回一個對象的hash值，具有相同值的object具有相同的hash值。 hash('python') 7070808359261009780
help()：調用系統(tǒng)內置的幫助系統(tǒng)。
isinstance()：判斷一個對象是否為該類的一個實例。
issubclass()：判斷一個類是否為另一個類的子類。
globals() : 返回當前全局變量的字典。
next(iterator[, default]) : 接收一個迭代器，返回迭代器中的數值，如果設置了default，則當迭代器中的元素遍歷后，輸出default內容。
reversed(sequence) ： 生成一個反轉序列的迭代器。 reversed('abc') ['c','b','a']
python的常用內置函數
1.abs() 函數返回數字的絕對值
abs(-40)=40
2. dict() 函數用于創(chuàng)建一個字典
dict()
{} ? ? ?#創(chuàng)建一個空字典類似于u={},字典的存取方式一般為key-value
例如u = {"username":"tom", ?"age":18}
3. help() 函數用于查看函數或模塊用途的詳細說明
help('math')查看math模塊的用處
a=[1,2,3,4]
help(a)查看列表list幫助信息
4.dir()獲得當前模塊的屬性列表
dir(help)
['__call__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']
5.min() 方法返回給定參數的最小值 /參數可以為序列
a=? min(10,20,30,40)
a
10
6. next() 返回迭代器的下一個項目
it = iter([1, 2, 3, 4, 5])
next(it)
1
next(it)
2
7. id() 函數用于獲取對象的內存地址
a=12
id(a)
1550569552
8.enumerate() 函數用于將一個可遍歷的數據對象(如列表、元組或字符串)組合為一個索引序列，同時列出數據和數據下標，一般用在 for 循環(huán)當中。
a=["tom","marry","leblan"]
list(enumerate(a))
[(0, 'tom'), (1, 'marry'), (2, 'leblan')]
9. oct() 函數將一個整數轉換成8進制字符串
oct(15)
'0o17'
oct(10)
'0o12'
10. bin() 返回一個整數 int 或者長整數 long int 的二進制表示
bin(10)
'0b1010'
bin(15)
'0b1111'
11.eval() 函數用來執(zhí)行一個字符串表達式，并返回表達式的值
eval('2+2')
4
12.int() 函數用于將一個字符串會數字轉換為整型
int(3)
3
int(3.6)
3
int(3.9)
3
int(4.0)
4
13.open() 函數用于打開一個文件，創(chuàng)建一個file對象，相關的方法才可以調用它進行讀寫
f=open('test.txt')
14.str() 函數將對象轉化為適于人閱讀的形式
str(3)
'3'
15. bool() 函數用于將給定參數轉換為布爾類型，如果沒有參數，返回 False
bool()
False
bool(1)
True
bool(10)
True
bool(10.0)
True
16.isinstance() 函數來判斷一個對象是否是一個已知的類型
a=5
isinstance(a,int)
True
isinstance(a,str)
False
17. sum() 方法對系列進行求和計算
sum([1,2,3],5)
11
sum([1,2,3])
6
18. super() 函數用于調用下一個父類(超類)并返回該父類實例的方法。super 是用來解決多重繼承問題的，直接用類名調用父類方法
class ? User(object):
? def__init__(self):
class Persons(User):
? ? ? ? super(Persons,self).__init__()
19. float() 函數用于將整數和字符串轉換成浮點數
float(1)
1.0
float(10)
10.0
20. iter() 函數用來生成迭代器
a=[1,2,3,4,5,6]
iter(a)
for i in iter(a):
... ? ? ? ? print(i)
...
1
2
3
4
5
6
21.tuple 函數將列表轉換為元組
a=[1,2,3,4,5,6]
tuple(a)
(1, 2, 3, 4, 5, 6)
22.len() 方法返回對象（字符、列表、元組等）長度或項目個數
s = "playbasketball"
len(s)
14
a=[1,2,3,4,5,6]
len(a)
6
23. property() 函數的作用是在新式類中返回屬性值
class User(object):
?def __init__(self,name):
? ? ? ? ? self.name = name
def get_name(self):
? ? ? ? ? return self.get_name
@property
?def name(self):
? ? ? ? ?return self_name
24.type() 函數返回對象的類型
25.list() 方法用于將元組轉換為列表
b=(1,2,3,4,5,6)
list(b)
[1, 2, 3, 4, 5, 6]
26.range() 函數可創(chuàng)建一個整數列表，一般用在 for 循環(huán)中
range(10)
range(0, 10)
range(10,20)
range(10, 20)
27. getattr() 函數用于返回一個對象屬性值
class w(object):
... ? ? ? ? ? ? s=5
...
a = w()
getattr(a,'s')
5
28. complex() 函數用于創(chuàng)建一個復數或者轉化一個字符串或數為復數。如果第一個參數為字符串，則不需要指定第二個參數
complex(1,2)
(1+2j)
complex(1)
(1+0j)
complex("1")
(1+0j)
29.max() 方法返回給定參數的最大值，參數可以為序列
b=(1,2,3,4,5,6)
max(b)
6
30. round() 方法返回浮點數x的四舍五入值
round(10.56)
11
round(10.45)
10
round(10.45,1)
10.4
round(10.56,1)
10.6
round(10.565,2)
10.56
31. delattr 函數用于刪除屬性
class Num(object):
...? ? a=1
...? ? b=2
...? ? c=3.
.. print1 = Num()
print('a=',print1.a)
a= 1
print('b=',print1.b)
b= 2
print('c=',print1.c)
c= 3
delattr(Num,'b')
print('b=',print1.b)
Traceback (most recent call last):? File "", line 1, inAttributeError: 'Num' object has no attribute 'b'
32. hash() 用于獲取取一個對象（字符串或者數值等）的哈希值
hash(2)
2
hash("tom")
-1675102375494872622
33. set() 函數創(chuàng)建一個無序不重復元素集，可進行關系測試，刪除重復數據，還可以計算交集、差集、并集等。
a= set("tom")
b = set("marrt")
a,b
({'t', 'm', 'o'}, {'m', 't', 'a', 'r'})
ab#交集
{'t', 'm'}
a|b#并集
{'t', 'm', 'r', 'o', 'a'}
a-b#差集
{'o'}
python對列表計時的方法：
使用“import”語句導入time包，在列表操作之前用time.time函數獲取當前時間，在列表操作之后，再用time.time獲取當前時間，用第二次的時間減去第一次的時間就可以了
示例如下：
執(zhí)行結果如下：
更多Python知識，請關注：Python自學網??！
重慶分公司
重慶分公司
