Comment tester si un horodatage est en secondes ou millisecondes?
supposons une variable donnée, elle contient un UNIX
de l'heure, mais si elle est en secondes ou millisecondes format est inconnu, je veux attribuer à une variable qui est en secondes format
Par Exemple:
unknown = 1398494489444 # This is millisecond
t = ???
mise à Jour: je comprends qu'il n'est pas possible de dire sans donner certaines limites, de sorte qu'ici
- current_ts - 86400 * 365 < inconnu < current_ts
Assume current_ts = current unix timestamp
3 réponses
Si vous conversion les valeurs maximales de timestamp avec X chiffres en millis vous obtenez quelque chose comme ceci:
- 999999999999999 (13 chiffres) signifie Sat Nov 20 2286 17: 46:39 UTC
- 99999999999999 (12 chiffres) signifie Sun Sep 09 2001 01:46: 39 UTC
- 9999999999999 (11 chiffres) signifie Sat Mar 03 1973 09:46: 39 UTC
vos horodateurs peuvent-ils être plus anciens que 2001? Sinon, je pense que vous êtes sûr de vérifier si le numéro de 13 chiffres ou plus - si oui, vous avez millisecondes, si vous n'avez secondes. Bien sûr, cela ne fonctionnera que jusqu'à ce que les horodateurs en secondes aient aussi 13 chiffres, ce qui signifie que les horodateurs en millisecondes auront 16 chiffres:
- 1000000000000000 (16 chiffres) signifie Fri Sep 27 33658 01:46: 40 mais d'ici là, je vivrai sur une planète à partir du système Centauri Alpha et les normes de temps auront probablement changé un peu:)
P.S. vous pouvez relâcher la condition à 12 chiffres ou plus, si vos horodateurs ne peuvent remonter au-delà de 1973. L'état ne devrait être ok jusqu':
- 100000000000000 (15 chiffres) signifie Wed Nov 16 5138 09: 46:40 parce que cela en secondes aura 12 chiffres et se chevauchera avec votre condition
au risque d'attirer des voix négatives, je tiens à ce qu'il soit dit officiellement que je ne le fais pas.
avec vos contraintes, il est trivial de détecter des horodateurs millisecondes. Même les repères temporels d'une année dans le passé sont encore plus grands que les repères temporels actuels.
il suffit de tester si le nombre est supérieur à l'horodatage courant; si c'est le cas, vous avez un horodatage en millisecondes:
now = time.mktime(time.gmtime())
if t > now:
# milliseconds, convert to seconds
t /= 1000.0
en divisant par 1000, vous convertissez le timestamp de nouveau à un exprimé en secondes et le par défaut time
les fonctions du module peuvent être appliquées.
c'est parce Que même un horodatage en millisecondes représentant un an dans le passé, interprété accidentellement comme un timestamp en secondes, serait mentir loin dans l'avenir:
>>> import time
>>> ts = time.mktime(time.gmtime())
>>> year_ago = ts - (86400 * 365)
>>> time.gmtime(year_ago * 1000) # misinterpret milliseconds as seconds
time.struct_time(tm_year=45395, tm_mon=7, tm_mday=9, tm_hour=14, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=190, tm_isdst=0)
Vous devez avoir un timestamp au début de 1970 avant de pouvoir confondre les deux gammes:
>>> now = time.mktime(time.gmtime())
>>> time.gmtime(ts / 1000) # misinterpret seconds as milliseconds
time.struct_time(tm_year=1970, tm_mon=1, tm_mday=17, tm_hour=5, tm_min=25, tm_sec=13, tm_wday=5, tm_yday=17, tm_isdst=0)
E. G. les horodateurs dans les 17 premiers jours après L'époque UNIX peuvent être confondus avec des horodateurs en millisecondes. Tout après cette date va être plus grand qu'un horodatage "en temps réel".
avec vos contraintes spécifiques, vous êtes chanceux que nous puissions garder les deux unités séparées si facilement. meilleure option est de ne pas se mettre dans cette situation en premier lieu. Ces données proviennent de quelque part; déterminez dès que possible quel type de données vous avez au lieu d'avoir à deviner plus tard. Aucun système ne vous donnera au hasard des horodateurs en quelques secondes une partie du temps, horodatage en millisecondes le reste du temps. Vous pouvez sûrement savoir sur la base d'autres informations quel type de données vous recherchez et soit convertir à ce moment-là ou annoter vos données pour inclure le type?