Tengo una función que devuelve información en segundos, pero necesito almacenar esa información en horas: minutos: segundos.
¿Hay una manera fácil de convertir los segundos a este formato en Python?
Tengo una función que devuelve información en segundos, pero necesito almacenar esa información en horas: minutos: segundos.
¿Hay una manera fácil de convertir los segundos a este formato en Python?
Respuestas:
Puedes usar la datetime.timedelta
función:
>>> import datetime
>>> str(datetime.timedelta(seconds=666))
'0:11:06'
str(datetime.timedelta(seconds=60*60*24+1))
='1 day, 0:00:01'
str(datetime.timedelta(seconds=round(666666.55)))
representa correctamente los días; suprime los segundos decimales.
timedelta
no es seguro para el desbordamiento y no puede realizar correctamente operaciones matemáticas, por ejemplo, str(timedelta(hours=8) - timedelta(hours=10))
el resultado es '-1 day, 22:00:00'
y la solución basada en enteros es exactamente para aquellas situaciones en las que necesita '-02:00:00'
.
Al usar la divmod()
función, que solo hace una división para producir tanto el cociente como el resto, puede obtener el resultado muy rápidamente con solo dos operaciones matemáticas:
m, s = divmod(seconds, 60)
h, m = divmod(m, 60)
Y luego use el formato de cadena para convertir el resultado en la salida deseada:
print('{:d}:{:02d}:{:02d}'.format(h, m, s)) # Python 3
print(f'{h:d}:{m:02d}:{s:02d}') # Python 3.6+
'%d:%02dmn' % (seconds / 60, seconds % 60)
d, h = divmod(h, 24)
.
m, d = divmod(m, 31)
. Oooops, no, no puedes. Peor aún, su código será incorrecto si entran segundos en el juego. Larga historia corta: usa timedelta
y no te metas con el calendario, te morderá.
timedelta
ocupa de los segundos bisiestos? Sospecho que no. Hay muchas aplicaciones donde esta simple matemática es más que suficiente.
str(timedelta(hours=8) - timedelta(hours=10))
el resultado es '-1 día, 22:00:00' así que ... idk si funciona con segundos intercalares pero no funciona con números negativos.
Apenas puedo nombrarlo de una manera fácil (al menos no recuerdo la sintaxis), pero es posible usar time.strftime , que brinda más control sobre el formateo:
from time import strftime
from time import gmtime
strftime("%H:%M:%S", gmtime(666))
'00:11:06'
strftime("%H:%M:%S", gmtime(60*60*24))
'00:00:00'
gmtime se usa para convertir segundos a un formato de tupla especial que strftime()
requiere.
Nota: Trunca después de las 23:59:59
time.strftime('%d %H:%M:%S', time.gmtime(1))
=> '1 día, 0:00:01'.
datetime
:':0>8'
formato:from datetime import timedelta
"{:0>8}".format(str(timedelta(seconds=66)))
# Result: '00:01:06'
"{:0>8}".format(str(timedelta(seconds=666777)))
# Result: '7 days, 17:12:57'
"{:0>8}".format(str(timedelta(seconds=60*60*49+109)))
# Result: '2 days, 1:01:49'
':0>8'
formato:"{}".format(str(timedelta(seconds=66)))
# Result: '00:01:06'
"{}".format(str(timedelta(seconds=666777)))
# Result: '7 days, 17:12:57'
"{}".format(str(timedelta(seconds=60*60*49+109)))
# Result: '2 days, 1:01:49'
time
:from time import gmtime
from time import strftime
# NOTE: The following resets if it goes over 23:59:59!
strftime("%H:%M:%S", gmtime(125))
# Result: '00:02:05'
strftime("%H:%M:%S", gmtime(60*60*24-1))
# Result: '23:59:59'
strftime("%H:%M:%S", gmtime(60*60*24))
# Result: '00:00:00'
strftime("%H:%M:%S", gmtime(666777))
# Result: '17:12:57'
# Wrong
"{:0>8}".format(timedelta(milliseconds=66)) '0:00:00.066000'
without ':0>8':
ejemplo faltan los primeros 0 {:0>8}
ceros a la izquierda 8 ceros.
time.time()-start
variable. Alguna idea? TypeError: non-empty format string passed to object.__format__
datetime.now()
lugar de time.time()
generar mi objeto timedelta y obtengo el mismo error.
str()
si se va usar un formato como 0>8
: "{:0>8}".format(str(datetime.timedelta(seconds=666777)))
. Mira esta respuesta para más información.
Este es mi truco rápido:
from humanfriendly import format_timespan
secondsPassed = 1302
format_timespan(secondsPassed)
# '21 minutes and 42 seconds'
Para obtener más información, visite: https://humanfriendly.readthedocs.io/en/latest/#humanfriendly.format_timespan
Si necesita obtener datetime.time
valor, puede usar este truco:
my_time = (datetime(1970,1,1) + timedelta(seconds=my_seconds)).time()
No puede agregar timedelta
a time
, pero puede agregarlo a datetime
.
UPD : Otra variación más de la misma técnica:
my_time = (datetime.fromordinal(1) + timedelta(seconds=my_seconds)).time()
En lugar de 1
usted, puede usar cualquier número mayor que 0. Aquí usamos el hecho de que datetime.fromordinal
siempre devolverá el datetime
objeto con un time
componente cero.
Así es como lo conseguí.
def sec2time(sec, n_msec=3):
''' Convert seconds to 'D days, HH:MM:SS.FFF' '''
if hasattr(sec,'__len__'):
return [sec2time(s) for s in sec]
m, s = divmod(sec, 60)
h, m = divmod(m, 60)
d, h = divmod(h, 24)
if n_msec > 0:
pattern = '%%02d:%%02d:%%0%d.%df' % (n_msec+3, n_msec)
else:
pattern = r'%02d:%02d:%02d'
if d == 0:
return pattern % (h, m, s)
return ('%d days, ' + pattern) % (d, h, m, s)
Algunos ejemplos:
$ sec2time(10, 3)
Out: '00:00:10.000'
$ sec2time(1234567.8910, 0)
Out: '14 days, 06:56:07'
$ sec2time(1234567.8910, 4)
Out: '14 days, 06:56:07.8910'
$ sec2time([12, 345678.9], 3)
Out: ['00:00:12.000', '4 days, 00:01:18.900']
str(datetime.timedelta(seconds=666))
666.0
y 666.1
valores.
El siguiente set funcionó para mí.
def sec_to_hours(seconds):
a=str(seconds//3600)
b=str((seconds%3600)//60)
c=str((seconds%3600)%60)
d=["{} hours {} mins {} seconds".format(a, b, c)]
return d
print(sec_to_hours(10000))
# ['2 hours 46 mins 40 seconds']
print(sec_to_hours(60*60*24+105))
# ['24 hours 1 mins 45 seconds']
dateutil.relativedelta
es conveniente si necesita acceder a horas, minutos y segundos como flotadores también. datetime.timedelta
No proporciona una interfaz similar.
from dateutil.relativedelta import relativedelta
rt = relativedelta(seconds=5440)
print(rt.seconds)
print('{:02d}:{:02d}:{:02d}'.format(
int(rt.hours), int(rt.minutes), int(rt.seconds)))
Huellas dactilares
40.0
01:30:40
seconds=5440
lugar de seconds=5540
. ¡Sin embargo, me gusta tu respuesta!
horas (h) calculadas por división de piso (por //) de segundos por 3600 (60 min / hr * 60 sec / min)
minutos (m) calculados por la división del piso de los segundos restantes (resto del cálculo de la hora, en%) por 60 (60 segundos / min)
de manera similar, segundos (s) por resto de cálculo de hora y minutos.
¡El resto es solo formateo de cadenas!
def hms(seconds):
h = seconds // 3600
m = seconds % 3600 // 60
s = seconds % 3600 % 60
return '{:02d}:{:02d}:{:02d}'.format(h, m, s)
print(hms(7500)) # Should print 02h05m00s
division = 3623 // 3600 #to hours
division2 = 600 // 60 #to minutes
print (division) #write hours
print (division2) #write minutes
PD: mi código no es profesional