python運行時間統計

1. 在python里用time.time判斷函數的執行時間靠譜嗎

使用time.time來統計函數的執行時間，程序只會執行一次，存在很大的隨機因素。
timtit包就可以重復執行函數多次，然後將多次執行結果取平均值。相比起來更優。
然而程序執行時間很大程度還受計算機性能的影響，衡量程序好壞更靠譜的手段是計算時間復雜度。

2. python 中多線程總運行時間的統計

子線程開啟後，讓主線程等待，也就是join方法，子線程全部執行完了，主線程才接著執行，這樣時間就可以統計了

3. python中程序運行時間的計算

單細胞中各種同類工具層出不重，往往需要比較軟體間的重現性，運行速度等，因此查閱了python中程序運行時間計算的各種方法。

程序中主要有兩種時間CPU time和Wall time, 前者就是CPU實際運行的時間，包含系統CPU time和程序CPU time；

4. python pandas 如何按日期統計

你好，你可以參考下面的代碼：

importpandasaspd
importdatetime,re
df=pd.read_csv("book1.csv")
print(df)

AA=df.sort_values(by=['asktime'])
print(AA)

dataDict={}
print("**********")
forindex,rowindf.iterrows():
print(row)
#print(row['asktime'],row['setment'])
t=re.split("s+",row['asktime'])[0]
print
iftindataDict:
ifrow['sentiment']indataDict[t]:
dataDict[t][row['sentiment']]+=1
else:
dataDict[t][row['sentiment']]=1
else:
dataDict[t]={}
dataDict[t][row['sentiment']]=1
print(dataDict)

5. python 統計 函數運行 次數。

你好：

我對代碼做了注釋：

#last是一個列表，裡面只有一個元素，就是1，說明已經運行一次
defcounter(last=[1]):
#last[0]將列表裡面的第一個元素取出，然後加1，賦值給next
next=last[0]+1
#修改列表裡面第一個元素的值
last[0]=next
#返回此時運行的次數
returnnext

6. python 計算程序運行了多長時間

python 計算程序運行時間：

6.760052s

一、import time

7. 找出python程序中運行時最耗時間的部分

1. 那就是profile和cProfile模塊：

   importcProfile
   cProfile.run('function....')

2. 另外，time模塊，在不同的函數的開頭和結尾分別計時，然後將兩個時間相減，就可以獲得這段函數的運行時間了，然後在看哪段函數占的時間比較大：

   importtime
   t1=time.time()
   ##youfunctionsegmenthere
   t2=time.time()
   timediff=t2-t1

8. Python測量程序運行時間，time.time與time.clock

現象描述：

1、time.clock 在win系統和linux系統下對相同程序的計時結果不一致

2、到底應該用什麼時間計時？為什麼用time.time與time.clock計時會有那麼大的差異

在計算機領域有多種時間。

第一種稱作CPU時間或執行時間，用於測量在執行一個程序時CPU所花費的時間。第二種稱作掛鍾時間，測量執行一個程序時的總時間。掛鍾時間也被稱作流逝時間或運行時間。與CPU時間相比，掛鍾時間通常長些，因為CPU執行測量的程序可能同時還在執行其它程序的指令。

另一個重要概念是所謂的系統時間，由系統時鍾測量。系統時間表示計算機系統時間傳遞的概念。要記住系統時鍾是可以由操作系統修改的，就是修改系統時間。

在Unix系統上，time.time的作用與Windows相同，但time.clock的意義不同。

在Unix系統上，time.clock以秒為單位返回當前處理器時間，例如，執行當前線程所花費的CPU時間。而在Windows上，它是以秒為單位的返回自首次調用該函數以來所流逝的系統時間。

以我遇到的Ubuntu系統上運行time.time和time.clock的例子：

time.time()顯示系統時間過去大概1秒，而time.clock()顯示花費在當前進程上的CPU時間只有於1毫秒。

而win下time.time()和time.clock()顯示系統時間都是大致過去了1秒

在測量程序准確性能時應該使用哪一個呢？

這要視情況而定。如果程序運行的系統能夠提供足夠的資源給程序，例如，一個運行基於Python的web應用程序的web伺服器，則使用time.clock()來測量程序會更有意義，因這個web應用程序可能是伺服器上的主要程序 。如果程序運行的系統上還同時運行著其它大量程序，則使用time.time()進行測量會更有意義。 如果不是這樣，就應該使用基於掛鍾的計時器來測量程序的性能，因為這樣通常能反應程序的環境。

放結論，一般情況下：

1、win用time.clock或time.time

2、linux 下用time.time  或 datetime.datetime.now().timestamp()

【1】（重要）https://blog.csdn.net/ao985438294363006/article/details/101349790    Python測量時間，用time.time還是time.clock 

9. 如何進行python性能分析

使用time工具粗糙定時

首先，我們可以使用快速然而粗糙的工具：古老的unix工具time，來為我們的代碼檢測運行時間。
1 $ time python yourprogram.py
2
3 real 0m1.028s
4 user 0m0.001s
5 sys 0m0.003s
上面三個輸入變數的意義在文章 stackoverflow article 中有詳細介紹。簡單的說：

real - 表示實際的程序運行時間
user - 表示程序在用戶態的cpu總時間
sys - 表示在內核態的cpu總時間

通過sys和user時間的求和，你可以直觀的得到系統上沒有其他程序運行時你的程序運行所需要的CPU周期。

若sys和user時間之和遠遠少於real時間，那麼你可以猜測你的程序的主要性能問題很可能與IO等待相關。

使用計時上下文管理器進行細粒度計時

我們的下一個技術涉及訪問細粒度計時信息的直接代碼指令。這是一小段代碼，我發現使用專門的計時測量是非常重要的：

timer.py
01 import time
02
03 class Timer(object):
04 def __init__(self, verbose=False):
05 self.verbose = verbose
06
07 def __enter__(self):
08 self.start = time.time()
09 return self
10
11 def __exit__(self, *args):
12 self.end = time.time()
13 self.secs = self.end - self.start
14 self.msecs = self.secs * 1000 # millisecs
15 if self.verbose:
16 print 'elapsed time: %f ms' % self.msecs

為了使用它，你需要用Python的with關鍵字和Timer上下文管理器包裝想要計時的代碼塊。它將會在你的代碼塊開始執行的時候啟動計時器，在你的代碼塊結束的時候停止計時器。

這是一個使用上述代碼片段的例子：
01 from timer import Timer
02 from redis import Redis
03 rdb = Redis()
04
05 with Timer() as t:
06 rdb.lpush("foo", "bar")
07 print "=> elasped lpush: %s s" % t.secs
08
09 with Timer as t:
10 rdb.lpop("foo")
11 print "=> elasped lpop: %s s" % t.secs

我經常將這些計時器的輸出記錄到文件中，這樣就可以觀察我的程序的性能如何隨著時間進化。

使用分析器逐行統計時間和執行頻率

Robert Kern有一個稱作line_profiler的不錯的項目，我經常使用它查看我的腳步中每行代碼多快多頻繁的被執行。

想要使用它，你需要通過pip安裝該python包：
1 $ pip install line_profiler

一旦安裝完成，你將會使用一個稱做「line_profiler」的新模組和一個「kernprof.py」可執行腳本。

想要使用該工具，首先修改你的源代碼，在想要測量的函數上裝飾@profile裝飾器。不要擔心，你不需要導入任何模組。kernprof.py腳本將會在執行的時候將它自動地注入到你的腳步的運行時。

primes.py
01 @profile
02 def primes(n):
03 if n==2:
04 return [2]
05 elif n<2:
06 return []
07 s=range(3,n+1,2)
08 mroot = n ** 0.5
09 half=(n+1)/2-1
10 i=0
11 m=3
12 while m <= mroot:
13 if s[i]:
14 j=(m*m-3)/2
15 s[j]=0
16 while j
17 s[j]=0
18 j+=m
19 i=i+1
20 m=2*i+3
21 return [2]+[x for x in s if x]
22 primes(100)
一旦你已經設置好了@profile裝飾器，使用kernprof.py執行你的腳步。
1 $ kernprof.py -l -v fib.py
-l選項通知kernprof注入@profile裝飾器到你的腳步的內建函數，-v選項通知kernprof在腳本執行完畢的時候顯示計時信息。上述腳本的輸出看起來像這樣：
01 Wrote profile results to primes.py.lprof
02 Timer unit: 1e-06 s
03
04 File: primes.py
05 Function: primes at line 2
06 Total time: 0.00019 s
07
08 Line # Hits Time Per Hit % Time Line Contents
09 ==============================================================
10 2 @profile
11 3 def primes(n):
12 4 1 2 2.0 1.1 if n==2:
13 5 return [2]
14 6 1 1 1.0 0.5 elif n<2:
15 7 return []
16 8 1 4 4.0 2.1 s=range(3,n+1,2)
17 9 1 10 10.0 5.3 mroot = n ** 0.5
18 10 1 2 2.0 1.1 half=(n+1)/2-1
19 11 1 1 1.0 0.5 i=0
20 12 1 1 1.0 0.5 m=3
21 13 5 7 1.4 3.7 while m <= mroot:
22 14 4 4 1.0 2.1 if s[i]:
23 15 3 4 1.3 2.1 j=(m*m-3)/2
24 16 3 4 1.3 2.1 s[j]=0
25 17 31 31 1.0 16.3 while j
26 18 28 28 1.0 14.7 s[j]=0
27 19 28 29 1.0 15.3 j+=m
28 20 4 4 1.0 2.1 i=i+1
29 21 4 4 1.0 2.1 m=2*i+3
30 22 50 54 1.1 28.4 return [2]+[x for x in s if x]

尋找具有高Hits值或高Time值的行。這些就是可以通過優化帶來最大改善的地方。

程序使用了多少內存？

現在我們對計時有了較好的理解，那麼讓我們繼續弄清楚程序使用了多少內存。我們很幸運，Fabian Pedregosa模仿Robert Kern的line_profiler實現了一個不錯的內存分析器。

首先使用pip安裝:
1 $ pip install -U memory_profiler
2 $ pip install psutil

（這里建議安裝psutil包，因為它可以大大改善memory_profiler的性能）。

就像line_profiler，memory_profiler也需要在感興趣的函數上面裝飾@profile裝飾器：
1 @profile
2 def primes(n):
3 ...
4 ...
想要觀察你的函數使用了多少內存，像下面這樣執行：
1 $ python -m memory_profiler primes.py
一旦程序退出，你將會看到看起來像這樣的輸出：
01 Filename: primes.py
02
03 Line # Mem usage Increment Line Contents
04 ==============================================
05 2 @profile
06 3 7.9219 MB 0.0000 MB def primes(n):
07 4 7.9219 MB 0.0000 MB if n==2:
08 5 return [2]
09 6 7.9219 MB 0.0000 MB elif n<2:
10 7 return []
11 8 7.9219 MB 0.0000 MB s=range(3,n+1,2)
12 9 7.9258 MB 0.0039 MB mroot = n ** 0.5
13 10 7.9258 MB 0.0000 MB half=(n+1)/2-1
14 11 7.9258 MB 0.0000 MB i=0
15 12 7.9258 MB 0.0000 MB m=3
16 13 7.9297 MB 0.0039 MB while m <= mroot:
17 14 7.9297 MB 0.0000 MB if s[i]:
18 15 7.9297 MB 0.0000 MB j=(m*m-3)/2
19 16 7.9258 MB -0.0039 MB s[j]=0
20 17 7.9297 MB 0.0039 MB while j
21 18 7.9297 MB 0.0000 MB s[j]=0
22 19 7.9297 MB 0.0000 MB j+=m
23 20 7.9297 MB 0.0000 MB i=i+1
24 21 7.9297 MB 0.0000 MB m=2*i+3
25 22 7.9297 MB 0.0000 MB return [2]+[x for x in s if x]

line_profiler和memory_profiler的IPython快捷方式

memory_profiler和line_profiler有一個鮮為人知的小竅門，兩者都有在IPython中的快捷命令。你需要做的就是在IPython會話中輸入以下內容：
1 %load_ext memory_profiler
2 %load_ext line_profiler

在這樣做的時候你需要訪問魔法命令%lprun和%mprun，它們的行為類似於他們的命令行形式。主要區別是你不需要使用@profiledecorator來修飾你要分析的函數。只需要在IPython會話中像先前一樣直接運行分析：
1 In [1]: from primes import primes
2 In [2]: %mprun -f primes primes(1000)
3 In [3]: %lprun -f primes primes(1000)

這樣可以節省你很多時間和精力，因為你的源代碼不需要為使用這些分析命令而進行修改。

內存泄漏在哪裡？

cPython解釋器使用引用計數做為記錄內存使用的主要方法。這意味著每個對象包含一個計數器，當某處對該對象的引用被存儲時計數器增加，當引用被刪除時計數器遞減。當計數器到達零時，cPython解釋器就知道該對象不再被使用，所以刪除對象，釋放佔用的內存。

如果程序中不再被使用的對象的引用一直被佔有，那麼就經常發生內存泄漏。

查找這種「內存泄漏」最快的方式是使用Marius Gedminas編寫的objgraph，這是一個極好的工具。該工具允許你查看內存中對象的數量，定位含有該對象的引用的所有代碼的位置。

10. python中怎麼結束運行時間統計

在start 和 end之間 加入你的代碼 程序運行結束時會列印運行時間

import time

start = time.time()

# 你的代碼

end = time.time()
print("程序運行了%.2f秒" % (end - start))