Dans cet article, nous allons voir comment nous pouvons voir le temps en millisecondes, c'est-à-dire un millième (1000e) de seconde, en utilisant Python. Il peut s'agir d'une simple curiosité, d'un code d'analyse comparative ou pour obtenir une heure très, très précise de la journée. Quelle que soit la raison, l'objectif de l'article est de savoir comment obtenir l'heure en millisecondes, plutôt que de savoir à quoi elle servira une fois que nous l'aurons ce.
Méthode 1 :millisecondes et temps fixe
La première méthode que nous allons examiner est basée sur la mesure du temps qui s'est écoulé depuis un point fixe dans le temps, que nous appelons "l'époque". Pour Python, et l'informatique en général, l'époque est le point où le temps commence et le passage du temps est donc mesuré par rapport à cela. Alors que l'époque peut varier selon le système d'exploitation, pour Unix et Windows, il s'agit du 1er janvier 1970 à minuit en heure UTC (Greenwich Mean Time sans ajustements à l'heure d'été). Si vous voulez savoir quelle est l'heure d'époque sur une plate-forme donnée, vous pouvez utiliser :
import time time.gmtime(0) # time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=0)
Comme j'utilise une machine Windows 10, la sortie ci-dessus confirme simplement que l'heure de début ou l'époque de Python sur ma machine est le 1er janvier 1970, 00:00:00.
Utiliser time.time()
L'heure Python Standard Library peut être utilisée pour renvoyer le temps en secondes depuis l'époque sous forme de nombre à virgule flottante :
import time time.time() # 1613649533.180575
Cela nous donne essentiellement le nombre de secondes qui se sont écoulées depuis l'époque, donc pour obtenir le temps en millisecondes, nous devons multiplier la valeur renvoyée par 1000. Pour l'esthétique, nous pouvons arrondir le nombre et convertir en entier :
import time int(round(time.time()*1000)) # 1613649588303
Bien qu'il s'agisse d'un bon moyen basique d'obtenir le temps, si vous mesurez le temps en millisecondes, vous recherchez probablement un niveau de précision que cela ne fournit pas. Malheureusement, le time.time est conçu pour obtenir le temps en secondes, il ne peut donc pas garantir que le système que vous utilisez renverra un temps avec une précision supérieure à celle-ci, c'est-à-dire 1 seconde.
time.time_ns()
Appréciant ce besoin de plus de précision, les versions 3.7 et ultérieures de Python intègrent une fonction de temps supplémentaire qui mesure le temps à la nanoseconde - un millier de millionième de seconde. Vous aurez peut-être, comme moi, besoin d'un instant pour y réfléchir - un millième de millionième de seconde…
Ainsi, bien que cette méthode ait clairement la précision que nous recherchons, pour obtenir le temps en millisecondes, nous devons encore diviser le nombre renvoyé par 1 000 000 (c'est-à-dire convertir les nanosecondes en millisecondes) :
import time time.time_ns() // 1000000 # 1613649695449
Comme la fonction renvoie automatiquement un entier, nous n'avons pas à nous soucier de l'arrondi ou de la conversion.
Méthode 2 :millisecondes et temps relatif
Si notre objectif est de mesurer la vitesse en millisecondes, pour le code de benchmarking par exemple, Python a plusieurs fonctions dans la bibliothèque de temps qui peuvent spécifiquement aider à cela. Nous allons en examiner deux, en particulier, qui peuvent être utilisées pour mesurer le temps en nanosecondes afin de nous donner la précision dont nous avons besoin.
Contrairement aux exemples de la méthode 1, aucune de ces fonctions n'a de relation définie avec le temps réel - l'époque, elles regardent ce que nous appelons le temps relatif. La valeur qu'ils renvoient n'est pas définie par rapport à un point de départ, mais peut être utilisée pour mesurer des intervalles de temps, comme le temps qu'il faut pour exécuter une tâche ou un morceau de code spécifique. .
time.monotonic_ns()
Cette fonction est utilisée pour obtenir la valeur d'une horloge monotone, une horloge qui ne peut pas revenir en arrière et qui n'est pas affectée par les mises à jour de l'horloge système. Comme la valeur de retour est indéfinie, c'est-à-dire que nous ne savons pas à quel point de départ elle se rapporte, elle a une utilisation limitée en soi. Cependant, nous pouvons intercaler du code entre des appels consécutifs pour mesurer le temps entre les appels et donc le temps qu'il a fallu pour exécuter notre code.
Dans l'exemple ci-dessous, nous imprimerons l'heure monotone de début et l'heure monotone de fin à des fins d'illustration car elles n'ont aucune valeur en elles-mêmes. Nous pouvons cependant les utiliser pour mesurer le temps entre les deux appels pour voir combien de temps il a fallu à Python pour exécuter la fonction d'impression. Comme la valeur de retour est en nanosecondes, nous devons diviser par 1 000 000 pour obtenir notre temps de réponse en millisecondes
import time
start = time.monotonic_ns()
print(start)
x=1
while(x<=100):
print(x)
x +=1
finish=time.monotonic_ns()
duration = finish - start
print(f"That took {duration//1000000}ms")
La sortie est :
176278031000000 1 2 3 .. 98 99 100 176278046000000 That took 15ms
time.perf_counter_ns()
Cette méthode est similaire au time.monotonic fonction décrite précédemment mais, comme son nom l'indique, est un compteur de performance. Il n'inclut pas le temps écoulé pendant le sommeil et s'applique à l'ensemble du système. Cela renvoie la valeur absolue du compteur mais comme ce retour n'est pas défini, comme avec la fonction time.monotonic, il a une utilisation limitée en soi.
Ainsi, comme avec la fonction time.monotonic, nous pouvons utiliser des appels consécutifs pour mesurer le temps entre les appels, et comme le retour est en nanosecondes, nous devons diviser par 1 000 000 pour obtenir des millisecondes :
import time
start = time.perf_counter_ns()
print(start)
x=1
while(x<=100):
print(x)
x +=1
finish = time.perf_counter_ns()
print(finish)
duration = finish - start
print(f"That took {duration//1000000}ms")
La sortie est :
80058697360400 1 2 3 .. 98 99 100 80058701461500 That took 4ms
Avec à la fois le time.perf_counter et time.monotonic fonctions, les heures de début et de fin que nous avons imprimées ne sont pas pertinentes en elles-mêmes, car nous ne savons pas à quoi elles se rapportent. Leur seule utilisation est de nous montrer le temps écoulé entre les appels.
Méthode 3 :millisecondes et heure de la journée
Enfin, nous allons voir comment nous pouvons faire en sorte que Python nous indique l'heure de la journée en millisecondes, et pour ce faire, nous utiliserons la bibliothèque standard Python datetime .
dateheure.dateheure.maintenant()
Cette fonction renvoie la date et l'heure système actuelles avec les attributs suivants :
année, mois, jour, heure, minute, seconde, microseconde
Si nous appelons simplement la fonction par elle-même, elle nous montrera la date et l'heure actuelles à mon emplacement, jusqu'à la microseconde (un millionième de seconde) :
import datetime datetime.datetime.now() # datetime.datetime(2021,2,18,12,21,7,163392)
La sortie ci-dessus m'indique local actuel il est temps
- Année :2021
- Mois :2 (février)
- Jour :18
- Heure :12
- Minutes :21
- Secondes :7
- Microsecondes :163 392
La chose à supporter est que le micorsecond L'attribut retourné est toujours en relation avec l'attribut seconds.
Maintenant, si nous voulons convertir les microsecondes en millisecondes que nous devons diviser par 1000, nous pouvons également utiliser une instruction d'impression pour aider à formater la fonction pour la lisibilité :
import datetime dt = datetime.datetime.now() print(dt) dt.microsecond / 1000
La sortie est :
2021-02-18 12:21:59.889660 889.66
La première ligne de la sortie imprime la date et l'heure actuelles, la deuxième ligne imprime le nombre de millisecondes à ce stade.
datetime.datetime.utcnow()
Une légère variation par rapport à l'exemple précédent utilise utcnow() au lieu de simplement now() . UTC fait référence à l'heure en temps universel coordonné ou en temps moyen de Greenwich (GMT) et est utile pour calculer les différences de temps absolues sans la confusion des fuseaux horaires. Comme j'habite à Londres, il n'y a pas de différence dans mon code entre now() et utcnow() mais nous le verrons en action de toute façon.
Si nous appelons la fonction sans aucune mise en forme, nous obtenons une sortie similaire à ce que nous avons vu auparavant, donc les attributs sont les mêmes :
import datetime datetime.datetime.utcnow() # datetime.datetime(2021, 2, 18, 12, 22, 45, 343352)
Nous pourrions obtenir nos millisecondes comme nous l'avons fait avec le now() fonction, et cela fonctionnerait tout aussi bien, mais regardons une autre méthode. Dans cet exemple, nous allons utiliser le strftime() méthode pour convertir notre datetime objet dans une chaîne :
import datetime
datetime.datetime.utcnow().strftime('%Y-%m-%d-%H:%M:%S:%f')
# ‘2021-02-18-12:23:34:474314'
Comme le dernier chiffre représente les microsecondes, si nous voulons afficher l'heure actuelle en millisecondes, nous pouvons ignorer les 3 derniers chiffres, en les découpant. Cela a le même effet que de diviser par 1000 convertissant ainsi ou le temps en microsecondes :
import datetime
print(datetime.datetime.utcnow().strftime('%Y-%m-%d-%H:%M:%S:%f')[:-3])
# 2021-02-18-12:24:28:401
Résumé
Nous avons examiné plusieurs façons d'utiliser Python pour nous montrer le temps en millisecondes. Alors que la mise à jour du simple time.time à time.time_ns contribue certainement à notre précision, il est difficile de fournir des recommandations sur les meilleures pratiques. Toutes les méthodes que nous avons vues fournissent une réponse, mais si c'est la bonne réponse dépend vraiment de la question que nous posons.
La clé est de trouver la bonne méthode pour répondre à vos besoins particuliers, des facteurs tels que le niveau de précision requis, le(s) emplacement(s) géographique(s) et le niveau de complexité détermineront tous la bonne approche. Heureusement, Python a plusieurs façons de nous aider à obtenir des millisecondes, donc cela pourrait dépendre de vos préférences personnelles.
