如何在Python中获取以毫秒为单位的当前时间？

使用time.time()：

import time


def current_milli_time():
return round(time.time() * 1000)

然后：

>>> current_milli_time()
1378761833768

另一个解决方案是你可以嵌入到自己的utils.py

import time as time_ #make sure we don't override time
def millis():
return int(round(time_.time() * 1000))

time.time()只能给出秒的分辨率，毫秒的首选方法是datetime。

from datetime import datetime
dt = datetime.now()
dt.microsecond

如果您希望在代码中使用一个简单的方法来返回带有datetime的毫秒：

from datetime import datetime
from datetime import timedelta


start_time = datetime.now()


# returns the elapsed milliseconds since the start of the program
def millis():
dt = datetime.now() - start_time
ms = (dt.days * 24 * 60 * 60 + dt.seconds) * 1000 + dt.microseconds / 1000.0
return ms

def TimestampMillisec64():
return int((datetime.datetime.utcnow() - datetime.datetime(1970, 1, 1)).total_seconds() * 1000)

我发现以毫秒为单位获取当前UTC时间的最简单方法是：

# timeutil.py
import datetime




def get_epochtime_ms():
return round(datetime.datetime.utcnow().timestamp() * 1000)


# sample.py
import timeutil




timeutil.get_epochtime_ms()

只是示例代码：

import time
timestamp = int(time.time()*1000.0)

输出： 1534343781311

对于Python 3.7+，使用time.time_ns()从纪元获取经过纳秒的时间。

这给出了以毫秒为单位的整数时间：

import time


ms = time.time_ns() // 1_000_000

毫秒乘以1000对于解决或使某些先决条件可接受可能是不错的。它可以用来填补数据库中从未真正使用过它的空白。尽管如此，对于需要精确计时的实际情况，它最终会失败。我不建议任何人将这种方法用于需要操作或在特定时间处理的关键任务操作。

例如： 在美国，往返ping为30-80ms……你不能只是将其舍入并有效地使用它。

我自己的例子要求每秒钟都有任务，这意味着如果我在第一个任务响应后四舍五入，我仍然会产生流转时长乘以每个主循环周期。这最终是每60秒一次的总函数调用。那是~1440一天…不太准确。

只是想让人们寻找更准确的推理，而不仅仅是解决从未真正使用过它的数据库差距。

如果您担心测量经过的时间，您应该使用单调时钟（python 3）。此时钟不受系统时钟更新的影响，例如，您会看到NTP查询是否调整了您的系统时间。

>>> import time
>>> millis = round(time.monotonic() * 1000)

它提供了以秒为单位的参考时间，可用于稍后比较以测量经过的时间。

如果您使用我的代码（如下），时间将以秒为单位出现，然后在小数点后以毫秒为单位。我认为Windows和Unix之间存在差异-如果有，请发表评论。

from time import time


x = time()
print(x)

我的结果（在Windows上）是：

1576095264.2682993

编辑：没有区别：）谢谢tc0nn

只是另一个使用Python 3+的datetime模块的解决方案。

round(datetime.datetime.timestamp(datetime.datetime.now()) * 1000)

unix以来的时间

from time import time
while True:
print(str(time()*1000)+'ms       \r', end='')

自程序开始以来的时间

from time import time
init = time()
while True:
print(str((time()-init)*1000)+'ms         \r', end='')

谢谢你抽出时间

在Python 3.8+中进行了一些测试后，我注意到这些选项给出了完全相同的结果，至少在Windows 10中是这样。

import time


# Option 1
unix_time_ms_1 = int(time.time_ns() / 1000000)
# Option 2
unix_time_ms_2 = int(time.time() * 1000)

随意使用你更喜欢的那个，我认为没有必要比这个更复杂的解决方案。

在3.7之后的Python版本中，最好的答案是使用time.perf_counter_ns()。如文档所述：

time.perf_counter() -> float

返回性能计数器的值（以小数秒为单位），即用于测量短持续时间的最高可用分辨率的时钟。它确实包括睡眠期间经过的时间，并且是系统范围的。返回值的参考点未定义，因此只有连续调用结果之间的差异才有效。

time.perf_counter_ns() -> int

类似于perf_counter（），但返回时间为纳秒

正如它所说，这将使用您的系统提供的最佳计数器，并且它是专门设计用于测量性能的（因此试图避免其他计时器的常见陷阱）。

它还为您提供了一个很好的整数纳秒数，因此只需除以1000000即可获得您的毫秒数：

start = time.perf_counter_ns()
# do some work
duration = time.perf_counter_ns() - start
print(f"Your duration was {duration // 1000000}ms.")

更新：感谢@Neuralmer。

的大多数高效方式之一：

(time.time_ns() + 500000) // 1000000  #rounding last digit (1ms digit)

或

time.time_ns() // 1000000          #flooring last digit (1ms digit)

这两种方法在其他方法中非常有效。

基准：

你可以在下面我自己的机器上看到一些不同方法的基准结果：

import time


t = time.perf_counter_ns()
for i in range(1000):
o = time.time_ns() // 1000000           #each 200 ns
t2 = time.perf_counter_ns()
print((t2 - t)//1000)




t = time.perf_counter_ns()
for i in range(1000):
o = (time.time_ns() + 500000) // 1000000  #each 227 ns
t2 = time.perf_counter_ns()
print((t2 - t)//1000)




t = time.perf_counter_ns()
for i in range(1000):
o = round(time.time_ns() / 1000000)    #each 456 ns
t2 = time.perf_counter_ns()
print((t2 - t)//1000)




t = time.perf_counter_ns()
for i in range(1000):
o = int(time.time_ns() / 1000000)      #each 467 ns
t2 = time.perf_counter_ns()
print((t2 - t)//1000)




t = time.perf_counter_ns()
for i in range(1000):
o = int(time.time()* 1000)          #each 319 ns
t2 = time.perf_counter_ns()
print((t2 - t)//1000)


t = time.perf_counter_ns()
for i in range(1000):
o = round(time.time()* 1000)       #each 342 ns
t2 = time.perf_counter_ns()
print((t2 - t)//1000)```