De huidige tijd in milliseconden opvragen in Python?

Hoe krijg ik de huidige tijd in milliseconden in Python?


Antwoord 1, autoriteit 100%

Met behulp van time.time():

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

Dan:

>>> current_milli_time()
1378761833768

Antwoord 2, autoriteit 11%

time.time()kan alleen resolutie geven aan de tweede, de voorkeursbenadering voor milliseconden is datetime.

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

Antwoord 3, autoriteit 10%

Vanaf versie 3.7kunt u time.time_ns()om de tijd te krijgen als verstreken nanoseconden vanaf het tijdperk.
Dus je kunt doen

ms = time.time_ns() // 1_000_000 

om tijd in milliseconden als geheel getal te krijgen.


Antwoord 4, autoriteit 7%

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

Antwoord 5, autoriteit 3%

Gewoon voorbeeldcode:

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

Uitvoer:
1534343781311


Antwoord 6

een andere oplossing is de functie die u kunt insluiten in uw eigen utils.py

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

Antwoord 7

Als je een eenvoudige methode in je code wilt die de milliseconden met datetime retourneert:

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

Antwoord 8

Als je mijn code (hieronder) gebruikt, wordt de tijd weergegeven in seconden en daarna in milliseconden na de komma. Ik denk dat er een verschil is tussen Windows en Unix – geef commentaar als dat zo is.

from time import time
x = time()
print(x)

mijn resultaat (op Windows) was:

1576095264.2682993

EDIT: er is geen verschil 🙂 Bedankt tc0nn


Antwoord 9

Als je je zorgen maakt over het meten van verstreken tijd, gebruik dan de monotone klok (python 3). Deze klok wordt niet beïnvloed door systeemklokupdates, zoals je zou zien als een NTP-query bijvoorbeeld je systeemtijd aanpaste.

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

Het biedt een referentietijd in seconden die kan worden gebruikt om later te vergelijken om de verstreken tijd te meten.


Antwoord 10

De eenvoudigste manier die ik heb gevonden om de huidige UTC-tijd in milliseconden te krijgen, is:

# timeutil.py
import datetime
def get_epochtime_ms():
    return round(datetime.datetime.utcnow().timestamp() * 1000)
# sample.py
import timeutil
timeutil.get_epochtime_ms()

Antwoord 11

In versies van Python na 3.7 is het beste antwoord het gebruik van time.perf_counter_ns(). Zoals vermeld in de documenten:

time.perf_counter() -> float

Retourneer de waarde (in fractionele seconden) van een prestatieteller, d.w.z. een klok met de hoogst beschikbare resolutie om een ​​korte duur te meten. Het omvat de tijd die is verstreken tijdens de slaap en is systeembreed. Het referentiepunt van de geretourneerde waarde is niet gedefinieerd, zodat alleen het verschil tussen de resultaten van opeenvolgende oproepen geldig is.

time.perf_counter_ns() -> int

Vergelijkbaar met perf_counter(), maar retourneert tijd als nanoseconden

Zoals het zegt, zal dit de beste teller gebruiken die uw systeem te bieden heeft, en het is specifiek ontworpen voor gebruik bij het meten van prestaties (en probeert daarom de veelvoorkomende valkuilen van andere timers te vermijden).

Het geeft je ook een mooi geheel aantal nanoseconden, dus deel gewoon door 1000000 om je milliseconden te krijgen:

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

Antwoord 12

Na wat testen in Python 3.8+ merkte ik dat die opties exact hetzelfde resultaat geven, in ieder geval in 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)

Voel je vrij om degene te gebruiken die je beter vindt en ik zie geen noodzaak voor een meer gecompliceerde oplossing dan deze.


Antwoord 13

Deze vermenigvuldigingen tot 1000 voor milliseconden kunnen redelijk zijn om een ​​bepaalde voorwaarde op te lossen of acceptabel te maken. Het kan worden gebruikt om een ​​leemte in uw database op te vullen die het nooit echt gebruikt. Hoewel, voor echte situaties die een nauwkeurige timing vereisen, het uiteindelijk zou mislukken. Ik zou niemand aanraden deze methode te gebruiken voor missiekritieke operaties die acties vereisen of verwerking op specifieke tijdstippen.

Bijvoorbeeld:
round-trip pings zijn 30-80 ms in de VS… Je kunt dat niet zomaar afronden en efficiënt gebruiken.

Mijn eigen voorbeeld vereist elke seconde taken, wat betekent dat als ik zou afronden nadat de eerste taken hadden gereageerd, ik nog steeds de verwerkingstijd zou oplopen die elke hoofdluscyclus vermenigvuldigd. Dit werd uiteindelijk elke 60 seconden een totale functieaanroep. dat is ~1440 per dag.. niet al te nauwkeurig.

Gewoon een idee voor mensen die op zoek zijn naar een meer accurate redenering die verder gaat dan het oplossen van een database-gat dat het nooit echt gebruikt.


Antwoord 14

Tijd sinds unix

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

Tijd sinds de start van het programma

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

Bedankt voor uw tijd


Antwoord 15

Een van demeestefficiëntemanieren:

(time.time_ns() + 500) // 1000  #rounding last digit (1ms digit)

of

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

Beide zijn onder andere zeer efficiënt.

BENCHMARK:

U kunt hieronder enkele benchmarkresultatenvan verschillende methoden op mijn eigen computer zien:

import time
t = time.perf_counter_ns()
for i in range(1000):
    o = time.time_ns() // 1000           #each 212 ns
t2 = time.perf_counter_ns()
print((t2 - t)//1000)
t = time.perf_counter_ns()
for i in range(1000):
    o = (time.time_ns() + 500) // 1000  #each 223 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() / 1000)    #each 640 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() / 1000)      #each 500 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 407 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 438 ns
t2 = time.perf_counter_ns()
print((t2 - t)//1000)```

Antwoord 16

Gewoon een andere oplossing met behulp van de datetimemodule voor Python 3+.

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

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Other episodes