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?

Puedes usar la datetime.timedeltafunción:

>>> import datetime
>>> str(datetime.timedelta(seconds=666))
'0:11:06'

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+

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

Utilizando datetime:

Con el ':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'

Sin el ':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'

Utilizando 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

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.timevalor, puede usar este truco:

my_time = (datetime(1970,1,1) + timedelta(seconds=my_seconds)).time()

No puede agregar timedeltaa 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 1usted, puede usar cualquier número mayor que 0. Aquí usamos el hecho de que datetime.fromordinalsiempre devolverá el datetimeobjeto con un timecomponente 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']

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.relativedeltaes conveniente si necesita acceder a horas, minutos y segundos como flotadores también. datetime.timedeltaNo 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

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

Puedes dividir segundos entre 60 para obtener los minutos

import time
seconds = time.time()
minutes = seconds / 60
print(minutes)

Cuando lo dividas por 60 nuevamente, obtendrás las horas

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