python微秒

A. 如何在python中比較微秒時間差

python中的最小時間單位是毫秒，沒辦法精確到微秒
用time包的time()函數可以獲得當前計算機的掛鍾時間，利用它可以獲得時間差
import time
time1 = time.time()
#要度量時間的程序
time2 = time.time()
print time2 - time1

B. 如何讓 Python 像 Julia 一樣快地運行

使用 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%。
我知道，一些讀者會說我不會進行同類比較。我不同意。請記住，我們現在的任務是使用主機語言以最佳的方式排序輸入數組。在這種情況下，最佳方法是使用一個內置的函數。

C. Python能不能產生微秒級別的時間戳

time.time()就可以, 乘1000就行了

>>>importtime
>>>time.time()
1509890332.4617682

D. python如何微秒級延時

python中的最小時間單位是毫秒，沒辦法精確到微秒
用time包的time()函數可以獲得當前計算機的掛鍾時間，利用它可以獲得時間差
import time
time1 = time.time()
#要度量時間的程序
time2 = time.time()
print time2 - time1

E. python獲取時間模塊關於毫秒的求解。

通過查閱文檔這一項表示的是microsecond
通過查字典microsecond表示微秒，不是毫秒，1秒=100萬微秒

F. python中兩個時間戳相減得到結果是不是秒數

是的。

python中的時間戳相減是微秒數，也就是千分之一秒。

時間戳欄位在MySQL中經常使用到，比如需要記錄一行數據創建的時間或修改的時間時，我們通常會使用時間戳即timestamp欄位。

timestamp欄位類型可存儲時間類型數據，timestamp所能存儲的時間范圍為：＇1970－01－0100：00：01．000000＇到＇2038－01－1903：14：07．999999＇。

timestamp欄位佔用4個位元組。在MySQL5．7版本，timestamp可以指定精度，即TIMESTAMP（fsp）中fsp可以指定一個介於0到6之間的可選值，以代表小數秒精度。值為0表示沒有小數部分，如果省略，則默認精度為0。

(6)python微秒擴展閱讀：

影響時間戳顯示的參數主要有兩個，分別是explicitdefaultsfortimestamp，timezone。

explicitdefaultsfor＿timestamp參數決定MySQL服務端對timestamp列中的默認值和｀NULL｀值的不同處理方法。此變數自MySQL5．6．6版本引入，分為全局級別和會話級別，可動態更新，默認值為OFF。

在默認情況下，如果timestamp列沒有顯式的指明null屬性，那麼該列會被自動加上not null屬性(而其他類型的列如果沒有被顯式的指定not null，那麼是允許null值的)。

如果往這個列中插入null值，會自動的設置該列的值為current timestamp值。

G. python時間可不可以精確到微秒

是可以的，python的time模塊中時間秒數小數位數很多，精度很高。

H. python date，datetime 和time的區別

這是三個不同類型的數據，例如 2015-11-21 10:51:20：

1. date是日期，表示的是 2015-11-21；

2. datetime是日期時間，表示的是 2015-11-21 10:51:20；

3. time是時間，表示的是 10:51:20。

I. python如何獲取數據刷新率毫秒

轉換time.time()函數返回的時間浮點數，來獲取當前毫秒時間。
先importtime模塊。getMS函數的返回值，就是一個長度為3的毫秒時間字元串，getTime函數將這個毫秒時間與小時分鍾秒合並成一個用冒號（:）分割的時間字元串。
秒，毫秒，微秒相互之間都是10^3的關系，以上代碼將時間轉換成微秒代碼，然後用1000去取余，就得到了當前時間的微秒值。這段代碼得到的是int，請按自己需要轉換成string。

J. python 計算時間差秒

python 計算時間差秒：

上例演示了計算當前時間向後10小時的時間。