#?-*-?coding:utf-8?-*-
網(wǎng)站建設(shè)哪家好,找創(chuàng)新互聯(lián)!專注于網(wǎng)頁設(shè)計、網(wǎng)站建設(shè)、微信開發(fā)、重慶小程序開發(fā)、集團企業(yè)網(wǎng)站建設(shè)等服務(wù)項目。為回饋新老客戶創(chuàng)新互聯(lián)還提供了鄂倫春免費建站歡迎大家使用!
binaryDic={'+':float.__add__,
'-':float.__sub__,
'*':float.__mul__,
'/':float.__truediv__,
'%':float.__mod__,
'**':float.__pow__,}
unaryDic={'-':float.__neg__,
'+':float.__pos__,}
priorDic=dict((('**',3),('*',2),('/',2),('%',2),('+',1),('-',1)))
def?is_float(s):
'判斷是否浮點數(shù)字符'
return?s.isdigit()?or?s=='.'
def?is_prior(firOpf,secOpf):
'判斷運算符的優(yōu)先級'
if?secOpf=='**':
return?False
return?priorDic[firOpf]=priorDic[secOpf]
def?wipe_brace(s,start=0):
's是以左括號開頭的字符串'
'此函數(shù)將消去括號,求出括號內(nèi)的值,并返回剩余字符'
pos=s.find(')',start)
if?s[1:pos].count('(')==s[1:pos].count(')'):
return?s[pos+1:]?,ieval(s[1:pos])?
return?wipe_brace(s,pos+1)
def?get_Longest_number(s,num=''):
's是以左括號或數(shù)字開頭的字符串'
'返回s首位開始的最長連續(xù)數(shù)字串和剩余字符串'
if?not?s?:
return?s,num
if?s[0]=='(':
return?wipe_brace(s)
if?is_float(s[0]):
return?get_Longest_number(s[1:],num+s[0])
return?s,num
def?get_val(fir='',opf='',sec=''):
'智能求值函數(shù).能進行一元,二元或純值運算'
if?opf:
if?sec:
return?str(binaryDic[opf](float(fir),float(sec)))
return?str(unaryDic[opf](float(fir)))
return?fir
def?get_safeSec(s,cmpOpf='**',neg='',safeSec='',):
'比較s的第一個二元運算符和cmpOpf的優(yōu)先級'
'以便獲得安全的第二個值'
if?not?s:
return?s,get_val(safeSec,neg)
if?not?safeSec:
if?s[0]=='+':
return?get_safeSec(s[1:],cmpOpf,neg)
if?s[0]=='-':
return?get_safeSec(s[1:],cmpOpf,''?if?neg=='-'?else?'-')??
if?is_float(s[0])?or?s[0]=='(':
rest,safeSec=get_Longest_number(s)
return?get_safeSec(rest,cmpOpf,neg,safeSec)
opfNum=?2?if?s[:2]=='**'?else?1
if?is_prior(cmpOpf,s[:opfNum]):
return?s,get_val(safeSec,neg)
rest,safeNum=get_safeSec(s[opfNum:],s[:opfNum])
return?get_safeSec(rest,cmpOpf,neg,get_val(safeSec,s[:opfNum],safeNum))
def?ieval(s='',fir='',opf='',sec=''):
'控制整個解析流程'
if?not?s:
return?get_val(fir,opf,sec)
if?not?fir:
if?s[0]=='-':????????????
return?ieval(s[1:],fir,''?if?opf=='-'?else?'-')
if?s[0]=='+':
return?ieval(s[1:],fir,opf)
if?is_float(s[0])?or?s[0]=='(':
return?ieval(*get_Longest_number(s),opf=opf)
if?not?sec:
if?not?opf:
opfNum=?2?if?s[:2]=='**'?else?1
rest,sec=get_safeSec(s[opfNum:],s[:opfNum])
return?ieval(rest,fir,s[:opfNum],sec)
if?s[:2]!='**':
return?ieval(s,get_val(fir,opf))
rest,sec=get_safeSec(s[2:])
return?ieval(rest,get_val(fir,'**',sec),opf)
return?ieval(s,get_val(fir,opf,sec))
if?__name__=='__main__':
test=['1+2*3*4*5+20',
'1+2*3',
'1.1+20.02+300.003',
'-2**2',
'(-2)**2',
'1+2*3**-2**(2-3)*2',
'-2**-2**-2**-2',
'(1+2)*(2+3)/(1-3)',?
'((9+3)/2)',?
'((1234)-1)',?
'1-3*--+++-2**--+++((-2))**--+++-(1-2)**--+++-2*2+1*2**6%9',
'((1+3*(-2)**2)*((2%3+((3+3)*2**3+1))*(1-3)*(1+2)+5*6)*4)']
for?x?in?test:
print(ieval(x),'___',eval(x))
結(jié)果:
141.0?___?141
7.0?___?7
321.123?___?321.123
-4.0?___?-4
4.0?___?4
3.309401076758503?___?3.309401076758503
-0.5582965649524321?___?-0.5582965649524321
-7.5?___?-7.5
6.0?___?6.0
1233.0?___?1233
6.242640687119286?___?6.242640687119286
-14352.0?___?-14352
Python中有3種不同的時間表示法
1.時間戳 timestamp? 是從1970年1月1日0時0分0秒開始的秒數(shù)
2.struct_time? ? 包含9個元素的tuple
3.format time 已經(jīng)格式化好便于閱讀的時間
使用時間需要使用time模塊
import time引入time模塊
time.time()方法獲取當(dāng)前的時間,以timestamp的形式
time.time()
1576372527.424447
time.localtime()方法:以struct_time的形式獲取當(dāng)前的當(dāng)?shù)貢r間
time.localtime()
time.struct_time(tm_year=2019, tm_mon=12, tm_mday=14,
tm_hour=20, tm_min=15, tm_sec=49, tm_wday=5, tm_yday=348, tm_isdst=0)
time.gmtime()方法:以struct_time的形式獲取當(dāng)前的格林尼治時間
從struct_time中獲取具體的年月日:
ctime.tm_year? ctime.tm_mon .....
ttm_tm_isdst = 1來告知mktime()現(xiàn)在處于夏令時,明確使用ttm.tm_isdst = 0來告知未處于夏令時
不同時間表示法的轉(zhuǎn)換
struct_time轉(zhuǎn)timestamp: time.mktime(struct_time)
timestamp轉(zhuǎn)struct_time: time.localtime(time.time())
單元測試(Unit Testing)
為程序編寫測試——如果做的到位——有助于減少bug的出現(xiàn),并可以提高我們對程序按預(yù)期目標運行的信心。通常,測試并不能保證正確性,因為對大多數(shù)程序而言, 可能的輸入范圍以及可能的計算范圍是如此之大,只有其中最小的一部分能被實際地進 行測試。盡管如此,通過仔細地選擇測試的方法和目標,可以提高代碼的質(zhì)量。
大量不同類型的測試都可以進行,比如可用性測試、功能測試以及整合測試等。這里, 我們只講單元測試一對單獨的函數(shù)、類與方法進行測試,確保其符合預(yù)期的行為。
TDD的一個關(guān)鍵點是,當(dāng)我們想添加一個功能時——比如為類添加一個方法—— 我們首次為其編寫一個測試用例。當(dāng)然,測試將失敗,因為我們還沒有實際編寫該方法。現(xiàn)在,我們編寫該方法,一旦方法通過了測試,就可以返回所有測試,確保我們新添加的代碼沒有任何預(yù)期外的副作用。一旦所有測試運行完畢(包括我們?yōu)樾鹿δ芫帉懙臏y試),就可以對我們的代碼進行檢查,并有理有據(jù)地相信程序行為符合我們的期望——當(dāng)然,前提是我們的測試是適當(dāng)?shù)摹?/p>
比如,我們編寫了一個函數(shù),該函數(shù)在特定的索引位置插入一個字符串,可以像下面這樣開始我們的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
對不返回任何參數(shù)的函數(shù)或方法(通常返回None),我們通常賦予其由pass構(gòu)成的一個suite,對那些返回值被試用的,我們或者返回一個常數(shù)(比如0),或者某個不變的參數(shù)——這也是我們這里所做的。(在更復(fù)雜的情況下,返回fake對象可能更有用一一對這樣的類,提供mock對象的第三方模塊是可用的。)
運行doctest時會失敗,并列出每個預(yù)期內(nèi)的字符串('ABCD-EF'、'ABCDE-F' 等),及其實際獲取的字符串(所有的都是'ABCD-EF')。一旦確定doctest是充分的和正確的,就可以編寫該函數(shù)的主體部分,在本例中只是簡單的return string[:position] + insert+string[position:]。(如果我們編寫的是 return string[:position] + insert,之后復(fù)制 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),因此沒必要寫一個總體的測試程序——因為模塊將自己搜索測試程序。這使得測試整個代碼樹或某一部分 (比如那些已經(jīng)起作用的模塊)變得很容易。那些對測試嚴重關(guān)切的人,在決定使用哪個測試工具之前,對這兩個(以及任何其他有吸引力的)第三方模塊進行研究都是值 得的。
創(chuàng)建doctest是直截了當(dāng)?shù)模何覀冊谀K中編寫測試、函數(shù)、類與方法的docstrings。 對于模塊,我們簡單地在末尾添加了 3行:
if __name__ =="__main__":
import doctest
doctest.testmod()
在程序內(nèi)部使用doctest也是可能的。比如,blocks.py程序(其模塊在后面)有自己函數(shù)的doctest,但以如下代碼結(jié)尾:
if __name__== "__main__":
main()
這里簡單地調(diào)用了程序的main()函數(shù),并且沒有執(zhí)行程序的doctest。要實驗程序的 doctest,有兩種方法。一種是導(dǎo)入doctest模塊,之后運行程序---比如,在控制臺中輸 入 python3 -m doctest blocks.py (在 Wndows 平臺上,使用類似于 C:Python3 lpython.exe 這樣的形式替代python3)。如果所有測試運行良好,就沒有輸出,因此,我們可能寧愿執(zhí)行python3-m doctest blocks.py-v,因為這會列出每個執(zhí)行的doctest,并在最后給出結(jié)果摘要。
另一種執(zhí)行doctest的方法是使用unittest模塊創(chuàng)建單獨的測試程序。在概念上, unittest模塊是根據(jù)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標識符中,連接符是無效的(避開這一約束是可能的,但最簡單的解決方案是使用總是有效模塊名的程序文件名,比如,使用下劃線替換連接符)。這里展示的結(jié)構(gòu)(創(chuàng)建一個測試套件,添加一個或多個測試用例或測試套件,運行總體的測試套件,輸出結(jié)果)是典型的機遇unittest的測試。運行時,這一特定實例產(chǎn)生如下結(jié)果:
...
.............................................................................................................
Ran 3 tests in 0.244s
OK
每次執(zhí)行一個測試用例時,都會輸出一個句點(因此上面的輸出最前面有3個句點),之后是一行連接符,再之后是測試摘要(如果有任何一個測試失敗,就會有更多的輸出信息)。
如果我們嘗試將測試分離開(典型情況下是要測試的每個程序和模塊都有一個測試用例),就不要再使用doctests,而是直接使用unittest模塊的功能——尤其是我們習(xí)慣于使用JUnit方法進行測試時ounittest模塊會將測試分離于代碼——對大型項目(測試編寫人員與開發(fā)人員可能不一致)而言,這種方法特別有用。此外,unittest單元測試編寫為獨立的Python模塊,因此,不會像在docstring內(nèi)部編寫測試用例時受到兼容性和明智性的限制。
unittest模塊定義了 4個關(guān)鍵概念。測試夾具是一個用于描述創(chuàng)建測試(以及用完之后將其清理)所必需的代碼的術(shù)語,典型實例是創(chuàng)建測試所用的一個輸入文件,最后刪除輸入文件與結(jié)果輸出文件。測試套件是一組測試用例的組合。測試用例是測試的基本單元—我們很快就會看到實例。測試運行者是執(zhí)行一個或多個測試套件的對象。
典型情況下,測試套件是通過創(chuàng)建unittest.TestCase的子類實現(xiàn)的,其中每個名稱 以“test”開頭的方法都是一個測試用例。如果我們需要完成任何創(chuàng)建操作,就可以在一個名為setUp()的方法中實現(xiàn);類似地,對任何清理操作,也可以實現(xiàn)一個名為 tearDown()的方法。在測試內(nèi)部,有大量可供我們使用的unittest.TestCase方法,包括 assertTrue()、assertEqual()、assertAlmostEqual()(對于測試浮點數(shù)很有用)、assertRaises() 以及更多,還包括很多對應(yīng)的逆方法,比如assertFalse()、assertNotEqual()、failIfEqual()、 failUnlessEqual ()等。
unittest模塊進行了很好的歸檔,并且提供了大量功能,但在這里我們只是通過一 個非常簡單的測試套件來感受一下該模塊的使用。這里將要使用的實例,該練習(xí)要求創(chuàng)建一個Atomic模塊,該模塊可以用作一 個上下文管理器,以確?;蛘咚懈淖兌紤?yīng)用于某個列表、集合或字典,或者所有改變都不應(yīng)用。作為解決方案提供的Atomic.py模塊使用30行代碼來實現(xiàn)Atomic類, 并提供了 100行左右的模塊doctest。這里,我們將創(chuàng)建test_Atomic.py模塊,并使用 unittest測試替換doctest,以便可以刪除doctest。
在編寫測試模塊之前,我們需要思考都需要哪些測試。我們需要測試3種不同的數(shù)據(jù)類型:列表、集合與字典。對于列表,需要測試的是插入項、刪除項或修改項的值。對于集合,我們必須測試向其中添加或刪除一個項。對于字典,我們必須測試的是插入一個項、修改一個項的值、刪除一個項。此外,還必須要測試的是在失敗的情況下,不會有任何改變實際生效。
結(jié)構(gòu)上看,測試不同數(shù)據(jù)類型實質(zhì)上是一樣的,因此,我們將只為測試列表編寫測試用例,而將其他的留作練習(xí)。test_Atomic.py模塊必須導(dǎo)入unittest模塊與要進行測試的Atomic模塊。
創(chuàng)建unittest文件時,我們通常創(chuàng)建的是模塊而非程序。在每個模塊內(nèi)部,我們定義一個或多個unittest.TestCase子類。比如,test_Atomic.py模塊中僅一個單獨的 unittest-TestCase子類,也就是TestAtomic (稍后將對其進行講解),并以如下兩行結(jié)束:
if name == "__main__":
unittest.main()
這兩行使得該模塊可以單獨運行。當(dāng)然,該模塊也可以被導(dǎo)入并從其他測試程序中運行——如果這只是多個測試套件中的一個,這一點是有意義的。
如果想要從其他測試程序中運行test_Atomic.py模塊,那么可以編寫一個與此類似的程序。我們習(xí)慣于使用unittest模塊執(zhí)行doctests,比如:
import unittest
import test_Atomic
suite = unittest.TestLoader().loadTestsFromTestCase(test_Atomic.TestAtomic)
runner = unittest.TextTestRunner()
pnnt(runner.run(suite))
這里,我們已經(jīng)創(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))
我們已經(jīng)使用了 unittest.TestCase.setUp()方法來創(chuàng)建單獨的測試數(shù)據(jù)片段。
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)
這里,我們直接在測試方法中編寫了測試代碼,而不需要一個內(nèi)部函數(shù),也不再使用unittest.TestCase.assertRaised()作為上下文管理器(期望代碼產(chǎn)生AttributeError)。 最后我們也使用了 Python 3.1 的 unittest.TestCase.assertListEqual()方法。
正如我們已經(jīng)看到的,Python的測試模塊易于使用,并且極為有用,在我們使用 TDD的情況下更是如此。它們還有比這里展示的要多得多的大量功能與特征——比如,跳過測試的能力,這有助于理解平臺差別——并且這些都有很好的文檔支持。缺失的一個功能——但nose與py.test提供了——是測試發(fā)現(xiàn),盡管這一特征被期望在后續(xù)的Python版本(或許與Python 3.2—起)中出現(xiàn)。
性能剖析(Profiling)
如果程序運行很慢,或者消耗了比預(yù)期內(nèi)要多得多的內(nèi)存,那么問題通常是選擇的算法或數(shù)據(jù)結(jié)構(gòu)不合適,或者是以低效的方式進行實現(xiàn)。不管問題的原因是什么, 最好的方法都是準確地找到問題發(fā)生的地方,而不只是檢査代碼并試圖對其進行優(yōu)化。 隨機優(yōu)化會導(dǎo)致引入bug,或者對程序中本來對程序整體性能并沒有實際影響的部分進行提速,而這并非解釋器耗費大部分時間的地方。
在深入討論profiling之前,注意一些易于學(xué)習(xí)和使用的Python程序設(shè)計習(xí)慣是有意義的,并且對提高程序性能不無裨益。這些技術(shù)都不是特定于某個Python版本的, 而是合理的Python程序設(shè)計風(fēng)格。第一,在需要只讀序列時,最好使用元組而非列表; 第二,使用生成器,而不是創(chuàng)建大的元組和列表并在其上進行迭代處理;第三,盡量使用Python內(nèi)置的數(shù)據(jù)結(jié)構(gòu) dicts、lists、tuples 而不實現(xiàn)自己的自定義結(jié)構(gòu),因為內(nèi)置的數(shù)據(jù)結(jié)構(gòu)都是經(jīng)過了高度優(yōu)化的;第四,從小字符串中產(chǎn)生大字符串時, 不要對小字符串進行連接,而是在列表中累積,最后將字符串列表結(jié)合成為一個單獨的字符串;第五,也是最后一點,如果某個對象(包括函數(shù)或方法)需要多次使用屬性進行訪問(比如訪問模塊中的某個函數(shù)),或從某個數(shù)據(jù)結(jié)構(gòu)中進行訪問,那么較好的做法是創(chuàng)建并使用一個局部變量來訪問該對象,以便提供更快的訪問速度。
Python標準庫提供了兩個特別有用的模塊,可以輔助調(diào)査代碼的性能問題。一個是timeit模塊——該模塊可用于對一小段Python代碼進行計時,并可用于諸如對兩個或多個特定函數(shù)或方法的性能進行比較等場合。另一個是cProfile模塊,可用于profile 程序的性能——該模塊對調(diào)用計數(shù)與次數(shù)進行了詳細分解,以便發(fā)現(xiàn)性能瓶頸所在。
為了解timeit模塊,我們將查看一些小實例。假定有3個函數(shù)function_a()、 function_b()、function_c(), 3個函數(shù)執(zhí)行同樣的計算,但分別使用不同的算法。如果將這些函數(shù)放于同一個模塊中(或分別導(dǎo)入),就可以使用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()構(gòu)造子的第一個參數(shù)是我們想要執(zhí)行并計時的代碼,其形式是字符串。這里,該字符串是“function_a(X,Y)”;第二個參數(shù)是可選的,還是一個待執(zhí)行的字符串,這一次是在待計時的代碼之前,以便提供一些建立工作。這里,我們從 __main__ (即this)模塊導(dǎo)入了待測試的函數(shù),還有兩個作為輸入數(shù)據(jù)傳入的變量(X 與Y),這兩個變量在該模塊中是作為全局變量提供的。我們也可以很輕易地像從其他模塊中導(dǎo)入數(shù)據(jù)一樣來進行導(dǎo)入操作。
調(diào)用timeit.Timer對象的timeit()方法時,首先將執(zhí)行構(gòu)造子的第二個參數(shù)(如果有), 之后執(zhí)行構(gòu)造子的第一個參數(shù)并對其執(zhí)行時間進行計時。timeit.Timer.timeit()方法的返回值是以秒計數(shù)的時間,類型是float。默認情況下,timeit()方法重復(fù)100萬次,并返回所 有這些執(zhí)行的總秒數(shù),但在這一特定案例中,只需要1000次反復(fù)就可以給出有用的結(jié)果, 因此對重復(fù)計數(shù)次數(shù)進行了顯式指定。在對每個函數(shù)進行計時后,使用重復(fù)次數(shù)對總數(shù)進行除法操作,就得到了平均執(zhí)行時間,并在控制臺中打印出函數(shù)名與執(zhí)行時間。
function_a() 0.001618 sec
function_b() 0.012786 sec
function_c() 0.003248 sec
在這一實例中,function_a()顯然是最快的——至少對于這里使用的輸入數(shù)據(jù)而言。 在有些情況下一一比如輸入數(shù)據(jù)不同會對性能產(chǎn)生巨大影響——可能需要使用多組輸入數(shù)據(jù)對每個函數(shù)進行測試,以便覆蓋有代表性的測試用例,并對總執(zhí)行時間或平均執(zhí)行時間進行比較。
有時監(jiān)控自己的代碼進行計時并不是很方便,因此timeit模塊提供了一種在命令行中對代碼執(zhí)行時間進行計時的途徑。比如,要對MyModule.py模塊中的函數(shù)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這樣的內(nèi)容來替換python3)。-m選項用于Python 解釋器,使其可以加載指定的模塊(這里是timeit),其他選項則由timeit模塊進行處理。 -n選項指定了循環(huán)計數(shù)次數(shù),-s選項指定了要建立,最后一個參數(shù)是要執(zhí)行和計時的代碼。命令完成后,會向控制臺中打印運行結(jié)果,比如:
1000 loops, best of 3: 1.41 msec per loop
之后我們可以輕易地對其他兩個函數(shù)進行計時,以便對其進行整體的比較。
cProfile模塊(或者profile模塊,這里統(tǒng)稱為cProfile模塊)也可以用于比較函數(shù) 與方法的性能。與只是提供原始計時的timeit模塊不同的是,cProfile模塊精確地展示 了有什么被調(diào)用以及每個調(diào)用耗費了多少時間。下面是用于比較與前面一樣的3個函數(shù)的代碼:
if __name__ == "__main__":
for function in ("function_a", "function_b", "function_c"):
cProfile.run("for i in ranged 1000): {0}(X, Y)".format(function))
我們必須將重復(fù)的次數(shù)放置在要傳遞給cProfile.run()函數(shù)的代碼內(nèi)部,但不需要做任何創(chuàng)建,因為模塊函數(shù)會使用內(nèi)省來尋找需要使用的函數(shù)與變量。這里沒有使用顯式的print()語句,因為默認情況下,cProfile.run()函數(shù)會在控制臺中打印其輸出。下面給出的是所有函數(shù)的相關(guān)結(jié)果(有些無關(guān)行被省略,格式也進行了稍許調(diào)整,以便與頁面適應(yīng)):
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 ("調(diào)用的次數(shù)")列列出了對指定函數(shù)(在filename:lineno(function)中列出) 的調(diào)用次數(shù)?;叵胍幌挛覀冎貜?fù)了 1000次調(diào)用,因此必須將這個次數(shù)記住。tottime (“總的時間”)列列出了某個函數(shù)中耗費的總時間,但是排除了函數(shù)調(diào)用的其他函數(shù)內(nèi)部花費的時間。第一個percall列列出了對函數(shù)的每次調(diào)用的平均時間(tottime // ncalls)。 cumtime ("累積時間")列出了在函數(shù)中耗費的時間,并且包含了函數(shù)調(diào)用的其他函數(shù)內(nèi)部花費的時間。第二個percall列列出了對函數(shù)的每次調(diào)用的平均時間,包括其調(diào)用的函數(shù)耗費的時間。
這種輸出信息要比timeit模塊的原始計時信息富有啟發(fā)意義的多。我們立即可以發(fā)現(xiàn),function_b()與function_c()使用了被調(diào)用5000次以上的生成器,使得它們的速度至少要比function_a()慢10倍以上。并且,function_b()調(diào)用了更多通常意義上的函數(shù),包括調(diào)用內(nèi)置的sorted()函數(shù),這使得其幾乎比function_c()還要慢兩倍。當(dāng)然,timeit() 模塊提供了足夠的信息來查看計時上存在的這些差別,但cProfile模塊允許我們了解為什么會存在這些差別。正如timeit模塊允許對代碼進行計時而又不需要對其監(jiān)控一樣,cProfile模塊也可以做到這一點。然而,從命令行使用cProfile模塊時,我們不能精確地指定要執(zhí)行的 是什么——而只是執(zhí)行給定的程序或模塊,并報告所有這些的計時結(jié)果。需要使用的 命令行是python3 -m cProfile programOrModule.py,產(chǎn)生的輸出信息與前面看到的一 樣,下面給出的是輸出信息樣例,格式上進行了一些調(diào)整,并忽略了大多數(shù)行:
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術(shù)語學(xué)中,原始調(diào)用指的就是非遞歸的函數(shù)調(diào)用。
以這種方式使用cProfile模塊對于識別值得進一步研究的區(qū)域是有用的。比如,這里 我們可以清晰地看到function_b()需要耗費更長的時間,但是我們怎樣獲取進一步的詳細資料?我們可以使用cProfile.run("function_b()")來替換對function_b()的調(diào)用?;蛘呖梢员4嫱耆膒rofile數(shù)據(jù)并使用pstats模塊對其進行分析。要保存profile,就必須對命令行進行稍許修改:python3 -m cProfile -o profileDataFile programOrModule.py。 之后可以對 profile 數(shù)據(jù)進行分析,比如啟動IDLE,導(dǎo)入pstats模塊,賦予其已保存的profileDataFile,或者也可以在控制臺中交互式地使用pstats。
下面給出的是一個非常短的控制臺會話實例,為使其適合頁面展示,進行了適當(dāng)調(diào)整,我們自己的輸入則以粗體展示:
$ 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命令的參數(shù)。還有其他一些可用的工具,可以提供profile數(shù)據(jù)的圖形化展示形式,比如 RunSnakeRun (), 該工具需要依賴于wxPython GUI庫。
使用timeit與cProfile模塊,我們可以識別出我們自己代碼中哪些區(qū)域會耗費超過預(yù)期的時間;使用cProfile模塊,還可以準確算岀時間消耗在哪里。
以上內(nèi)容部分摘自視頻課程 05后端編程Python-19調(diào)試、測試和性能調(diào)優(yōu)(下) ,更多實操示例請參照視頻講解。跟著張員外講編程,學(xué)習(xí)更輕松,不花錢還能學(xué)習(xí)真本領(lǐng)。
def?next_sec(timestr):
from?datetime?import?datetime,?timedelta
time_format?=?'%Y-%m-%d?%H:%M:%S'
time_now?=?datetime.strptime(timestr,?time_format)
time_next_sec?=?time_now?+?timedelta(seconds=1)
return?time_next_sec.strftime(time_format)
print(next_sec('2004-12-31?23:59:59'))
#第一題:
from?__future__?import?division
print?'請依次輸入體重(kg)與身高(m):'
weight?=?float(raw_input())
height?=?float(raw_input())
print?"{:.2f}".format(weight/(height**2))
#第二題:
print?'請輸入一個秒數(shù):'
sec?=?int(raw_input())
print?str(sec/3600)+'?'+str(sec%3600/60)+'?'+str(sec%60)
#第三題:
from?__future__?import?division
import?math
print?'請依次輸入三角形三邊值a,?b?,c:'
a?=?int(raw_input())
b?=?int(raw_input())
c?=?int(raw_input())
print?"{:.1f}".format(math.degrees(math.acos((a**2?+?b**2?-?c**2)/(2*a*b))))
你復(fù)制的?問題還復(fù)制不全,汗啊。。。這么多問題?連個分也沒有。。。人家計算BMI是用的平方,你這里還給了個錯的公式,還能不能認真點兒。
1、python中要把字符串轉(zhuǎn)換成日期格式需要使用time模塊中的strptime函數(shù),例子如下:
執(zhí)行結(jié)果如下:
time.struct_time(tm_year=2016, tm_mon=5, tm_mday=9, tm_hour=21, tm_min=9, tm_sec=30, tm_wday=0, tm_yday=130, tm_isdst=-1)
2、函數(shù)說明:
第一個參數(shù)是要轉(zhuǎn)換成日期格式的字符串,第二個參數(shù)是字符串的格式,下面函數(shù)可以看一下。
名稱欄目:python中sec函數(shù),sec函數(shù)相關(guān)知識
當(dāng)前路徑:http://www.muchs.cn/article28/hcphcp.html
成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián),為您提供微信小程序、定制網(wǎng)站、定制開發(fā)、、網(wǎng)頁設(shè)計公司、電子商務(wù)
聲明:本網(wǎng)站發(fā)布的內(nèi)容(圖片、視頻和文字)以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主,如果涉及侵權(quán)請盡快告知,我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場,如需處理請聯(lián)系客服。電話:028-86922220;郵箱:631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載,或轉(zhuǎn)載時需注明來源: 創(chuàng)新互聯(lián)