Como encontro a diferença horária entre dois objetos datetime em python?

354

Como faço para saber a diferença horária em minutos entre dois datetimeobjetos?

Hobhouse
fonte

Respostas:

374
>>> import datetime
>>> first_time = datetime.datetime.now()
>>> later_time = datetime.datetime.now()
>>> difference = later_time - first_time
>>> seconds_in_day = 24 * 60 * 60
datetime.timedelta(0, 8, 562000)
>>> divmod(difference.days * seconds_in_day + difference.seconds, 60)
(0, 8)      # 0 minutes, 8 seconds

Subtrair o tempo posterior da primeira vez difference = later_time - first_timecria um objeto datetime que mantém apenas a diferença. No exemplo acima, são 0 minutos, 8 segundos e 562000 microssegundos.

SilentGhost
fonte
2
Referência: docs.python.org/library/datetime.html#datetime-objects . Leia "operações suportadas".
S.Lott
@SilentGhost, Como obter horas, minutos, segundos
Mulagala
11
@markcial: deloreandeturpa datetime, pytzabordagem , por exemplo, o exemplo de código inicial pode ser escrito como d = datetime.now(timezone(EST))(uma linha legível em vez de cinco).
JFS
11
Nota: você deve ter cuidado ao executar aritmética de data / hora em objetos de data e hora ingênuos que representam a hora local. Pode falhar, por exemplo, nas transições de horário de verão. Veja o link com mais detalhes na minha resposta
jfs
Como c é usado para encontrar diferença em termos de dias, minutos, segundos?
Zeeshan Mahmood
152

Novo no Python 2.7 é o timedeltamétodo de instância .total_seconds(). Nos documentos do Python, isso é equivalente a (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / 10**6.

Referência: http://docs.python.org/2/library/datetime.html#datetime.timedelta.total_seconds

>>> import datetime
>>> time1 = datetime.datetime.now()
>>> time2 = datetime.datetime.now() # waited a few minutes before pressing enter
>>> elapsedTime = time2 - time1
>>> elapsedTime
datetime.timedelta(0, 125, 749430)
>>> divmod(elapsedTime.total_seconds(), 60)
(2.0, 5.749430000000004) # divmod returns quotient and remainder
# 2 minutes, 5.74943 seconds
Ryan Stanley
fonte
107

Usando exemplo datetime

>>> from datetime import datetime
>>> then = datetime(2012, 3, 5, 23, 8, 15)        # Random date in the past
>>> now  = datetime.now()                         # Now
>>> duration = now - then                         # For build-in functions
>>> duration_in_s = duration.total_seconds()      # Total number of seconds between dates

Duração em anos

>>> years = divmod(duration_in_s, 31536000)[0]    # Seconds in a year=365*24*60*60 = 31536000.

Duração em dias

>>> days  = duration.days                         # Build-in datetime function
>>> days  = divmod(duration_in_s, 86400)[0]       # Seconds in a day = 86400

Duração em horas

>>> hours = divmod(duration_in_s, 3600)[0]        # Seconds in an hour = 3600

Duração em minutos

>>> minutes = divmod(duration_in_s, 60)[0]        # Seconds in a minute = 60

Duração em segundos

>>> seconds = duration.seconds                    # Build-in datetime function
>>> seconds = duration_in_s

Duração em microssegundos

>>> microseconds = duration.microseconds          # Build-in datetime function  

Duração total entre as duas datas

>>> days    = divmod(duration_in_s, 86400)        # Get days (without [0]!)
>>> hours   = divmod(days[1], 3600)               # Use remainder of days to calc hours
>>> minutes = divmod(hours[1], 60)                # Use remainder of hours to calc minutes
>>> seconds = divmod(minutes[1], 1)               # Use remainder of minutes to calc seconds
>>> print("Time between dates: %d days, %d hours, %d minutes and %d seconds" % (days[0], hours[0], minutes[0], seconds[0]))

ou simplesmente:

>>> print(now - then)

Editar 2019 Como essa resposta ganhou força, adicionarei uma função que pode simplificar o uso de alguns

from datetime import datetime

def getDuration(then, now = datetime.now(), interval = "default"):

    # Returns a duration as specified by variable interval
    # Functions, except totalDuration, returns [quotient, remainder]

    duration = now - then # For build-in functions
    duration_in_s = duration.total_seconds() 

    def years():
      return divmod(duration_in_s, 31536000) # Seconds in a year=31536000.

    def days(seconds = None):
      return divmod(seconds if seconds != None else duration_in_s, 86400) # Seconds in a day = 86400

    def hours(seconds = None):
      return divmod(seconds if seconds != None else duration_in_s, 3600) # Seconds in an hour = 3600

    def minutes(seconds = None):
      return divmod(seconds if seconds != None else duration_in_s, 60) # Seconds in a minute = 60

    def seconds(seconds = None):
      if seconds != None:
        return divmod(seconds, 1)   
      return duration_in_s

    def totalDuration():
        y = years()
        d = days(y[1]) # Use remainder to calculate next variable
        h = hours(d[1])
        m = minutes(h[1])
        s = seconds(m[1])

        return "Time between dates: {} years, {} days, {} hours, {} minutes and {} seconds".format(int(y[0]), int(d[0]), int(h[0]), int(m[0]), int(s[0]))

    return {
        'years': int(years()[0]),
        'days': int(days()[0]),
        'hours': int(hours()[0]),
        'minutes': int(minutes()[0]),
        'seconds': int(seconds()),
        'default': totalDuration()
    }[interval]

# Example usage
then = datetime(2012, 3, 5, 23, 8, 15)
now = datetime.now()

print(getDuration(then)) # E.g. Time between dates: 7 years, 208 days, 21 hours, 19 minutes and 15 seconds
print(getDuration(then, now, 'years'))      # Prints duration in years
print(getDuration(then, now, 'days'))       #                    days
print(getDuration(then, now, 'hours'))      #                    hours
print(getDuration(then, now, 'minutes'))    #                    minutes
print(getDuration(then, now, 'seconds'))    #                    seconds
Attaque
fonte
7
Não sei por que ninguém te agradeceu. Muito obrigado por uma resposta tão precisa. @Attaque
Amandeep Singh Sawhney
Erro TypeError: 'float' object is not subscriptableao usar:then = datetime(2017, 8, 11, 15, 58, tzinfo=pytz.UTC) now = datetime(2018, 8, 11, 15, 58, tzinfo=pytz.UTC) getDuration(then, now, 'years')
Piotr Wasilewicz:
11
Isso porque não posso contar o número de segundos em um ano :) 365 * 24 * 60 * 60 = 31536000 e não 31556926. Atualizei a resposta e as funções e ele deve funcionar agora.
Attaque
11
Essa deve ser a resposta aceita.
saran3h
28

Apenas subtraia um do outro. Você recebe um timedeltaobjeto com a diferença.

>>> import datetime
>>> d1 = datetime.datetime.now()
>>> d2 = datetime.datetime.now() # after a 5-second or so pause
>>> d2 - d1
datetime.timedelta(0, 5, 203000)

Você pode converter dd.days, dd.secondse dd.microsecondspara minutos.

Vinay Sajip
fonte
Quais são esses parâmetros? Comentários seria bom
TheRealChx101
22

Se a, bsão objetos de data e hora, para encontrar a diferença de horário entre eles no Python 3:

from datetime import timedelta

time_difference = a - b
time_difference_in_minutes = time_difference / timedelta(minutes=1)

Nas versões anteriores do Python:

time_difference_in_minutes = time_difference.total_seconds() / 60

Se a, bsão objetos de data e hora ingênuos, como retornados pordatetime.now() então o resultado pode estar errado se os objetos representam hora local com diferentes UTC compensações por exemplo, transições em torno do horário de verão ou para últimos datas / futuras. Mais detalhes: descubra se 24 horas se passaram entre as datas - Python .

Para obter resultados confiáveis, use a hora UTC ou os objetos de data e hora com reconhecimento de fuso horário.

jfs
fonte
17

Use divmod:

now = int(time.time()) # epoch seconds
then = now - 90000 # some time in the past

d = divmod(now-then,86400)  # days
h = divmod(d[1],3600)  # hours
m = divmod(h[1],60)  # minutes
s = m[1]  # seconds

print '%d days, %d hours, %d minutes, %d seconds' % (d[0],h[0],m[0],s)
tgwaste
fonte
11
Isso deve ser colocado no módulo datetime. Eu simplesmente não consigo entender por que ele usou apenas alguns dias, segundos e millis ...
paulochf
Isso não responde à pergunta sobre objetos de data e hora.
precisa saber é o seguinte
10

É assim que obtenho o número de horas decorridas entre dois objetos datetime.datetime:

before = datetime.datetime.now()
after  = datetime.datetime.now()
hours  = math.floor(((after - before).seconds) / 3600)
Tony
fonte
9
Isso não funcionará: timedelta.secondsfornece apenas o número de segundos armazenados explicitamente - que a documentação garante que totalizará menos de um dia. Você deseja (after - before).total_seconds(), que fornece o número de segundos que abrangem todo o delta.
Lvc
11
(after - before).total_seconds() // 3600(Python 2.7) ou (after - before) // timedelta(seconds=3600)(Python 3)
jfs 26/05
@lvc Meu código antigo foi realmente escrito dessa maneira, e eu pensei que estava sendo inteligente e "consertando". Obrigado pela correção.
26413 Tony
@JFSebastian Obrigado por isso, eu esqueci o operador //. E eu gosto mais da sintaxe py3, mas estou usando o 2.7.
26413 Tony
9

Para encontrar apenas o número de dias: timedelta possui um atributo 'days'. Você pode simplesmente consultar isso.

>>>from datetime import datetime, timedelta
>>>d1 = datetime(2015, 9, 12, 13, 9, 45)
>>>d2 = datetime(2015, 8, 29, 21, 10, 12)
>>>d3 = d1- d2
>>>print d3
13 days, 15:59:33
>>>print d3.days
13
griknus17
fonte
5

Apenas pensei que poderia ser útil mencionar a formatação também em relação ao timedelta. strptime () analisa uma string que representa uma hora de acordo com um formato.

from datetime import datetime

datetimeFormat = '%Y/%m/%d %H:%M:%S.%f'    
time1 = '2016/03/16 10:01:28.585'
time2 = '2016/03/16 09:56:28.067'  
time_dif = datetime.strptime(time1, datetimeFormat) - datetime.strptime(time2,datetimeFormat)
print(time_dif)

Isso produzirá: 0: 05: 00.518000

pardal
fonte
3

Eu uso algo assim:

from datetime import datetime

def check_time_difference(t1: datetime, t2: datetime):
    t1_date = datetime(
        t1.year,
        t1.month,
        t1.day,
        t1.hour,
        t1.minute,
        t1.second)

    t2_date = datetime(
        t2.year,
        t2.month,
        t2.day,
        t2.hour,
        t2.minute,
        t2.second)

    t_elapsed = t1_date - t2_date

    return t_elapsed

# usage 
f = "%Y-%m-%d %H:%M:%S+01:00"
t1 = datetime.strptime("2018-03-07 22:56:57+01:00", f)
t2 = datetime.strptime("2018-03-07 22:48:05+01:00", f)
elapsed_time = check_time_difference(t1, t2)

print(elapsed_time)
#return : 0:08:52
Softmixt
fonte
2
você obtém datas perfeitamente boas, por que as copia? isso é 75% do seu código pode ser expresso porreturn t1-t2
Patrick Artner 20/18
2

é encontrar a diferença entre a hora atual e as 9h30.

t=datetime.now()-datetime.now().replace(hour=9,minute=30)
nidheesh
fonte
1

Esta é a minha abordagem usando mktime .

from datetime import datetime, timedelta
from time import mktime

yesterday = datetime.now() - timedelta(days=1)
today = datetime.now()

difference_in_seconds = abs(mktime(yesterday.timetuple()) - mktime(today.timetuple()))
difference_in_minutes = difference_in_seconds / 60
Eduardo
fonte
mktime()espera a hora local como uma entrada. A hora local pode ser ambígua e, mktime()nesse caso, pode retornar uma resposta errada. Use em a - bvez disso (a, b - objetos datetime) . mktime()é desnecessário e às vezes está errado. Não use neste caso.
JFS
@AnneTheAgile, corrigido, minha falha na importação. Testado em Python 2.7.12
Eduardo
1

De outras maneiras para obter diferença entre data;

import dateutil.parser
import datetime
last_sent_date = "" # date string
timeDifference = current_date - dateutil.parser.parse(last_sent_date)
time_difference_in_minutes = (int(timeDifference.days) * 24 * 60) + int((timeDifference.seconds) / 60)

Portanto, obtenha saída em min.

obrigado

Anurag Pandey
fonte
1

Eu usei diferenças de tempo para testes de integração contínua para verificar e melhorar minhas funções. Aqui está um código simples, se alguém precisar

from datetime import datetime

class TimeLogger:
    time_cursor = None

    def pin_time(self):
        global time_cursor
        time_cursor = datetime.now()

    def log(self, text=None) -> float:
        global time_cursor

        if not time_cursor:
            time_cursor = datetime.now()

        now = datetime.now()
        t_delta = now - time_cursor

        seconds = t_delta.total_seconds()

        result = str(now) + ' tl -----------> %.5f' % seconds
        if text:
            result += "   " + text
        print(result)

        self.pin_time()

        return seconds


time_logger = TimeLogger()

Usando:

from .tests_time_logger import time_logger
class Tests(TestCase):
    def test_workflow(self):
    time_logger.pin_time()

    ... my functions here ...

    time_logger.log()

    ... other function(s) ...

    time_logger.log(text='Tests finished')

e eu tenho algo parecido na saída do log

2019-12-20 17:19:23.635297 tl -----------> 0.00007
2019-12-20 17:19:28.147656 tl -----------> 4.51234   Tests finished
Serg Smyk
fonte
0

Com base na ótima resposta do @Attaque , proponho uma versão simplificada mais curta da calculadora de diferença de data e hora:

seconds_mapping = {
    'y': 31536000,
    'm': 2628002.88, # this is approximate, 365 / 12; use with caution
    'w': 604800,
    'd': 86400,
    'h': 3600,
    'min': 60,
    's': 1,
    'mil': 0.001,
}

def get_duration(d1, d2, interval, with_reminder=False):
    if with_reminder:
        return divmod((d2 - d1).total_seconds(), seconds_mapping[interval])
    else:
        return (d2 - d1).total_seconds() / seconds_mapping[interval]

Eu mudei para evitar declarar funções repetitivas, removi o bonito intervalo padrão de impressão e adicionei suporte para milissegundos, semanas e meses ISO (os meses em mente são apenas aproximados, com base na suposição de que cada mês é igual a 365/12).

Qual produz:

d1 = datetime(2011, 3, 1, 1, 1, 1, 1000)
d2 = datetime(2011, 4, 1, 1, 1, 1, 2500)

print(get_duration(d1, d2, 'y', True))      # => (0.0, 2678400.0015)
print(get_duration(d1, d2, 'm', True))      # => (1.0, 50397.12149999989)
print(get_duration(d1, d2, 'w', True))      # => (4.0, 259200.00149999978)
print(get_duration(d1, d2, 'd', True))      # => (31.0, 0.0014999997802078724)
print(get_duration(d1, d2, 'h', True))      # => (744.0, 0.0014999997802078724)
print(get_duration(d1, d2, 'min', True))    # => (44640.0, 0.0014999997802078724)
print(get_duration(d1, d2, 's', True))      # => (2678400.0, 0.0014999997802078724)
print(get_duration(d1, d2, 'mil', True))    # => (2678400001.0, 0.0004999997244524721)

print(get_duration(d1, d2, 'y', False))     # => 0.08493150689687975
print(get_duration(d1, d2, 'm', False))     # => 1.019176965856293
print(get_duration(d1, d2, 'w', False))     # => 4.428571431051587
print(get_duration(d1, d2, 'd', False))     # => 31.00000001736111
print(get_duration(d1, d2, 'h', False))     # => 744.0000004166666
print(get_duration(d1, d2, 'min', False))   # => 44640.000024999994
print(get_duration(d1, d2, 's', False))     # => 2678400.0015
print(get_duration(d1, d2, 'mil', False))   # => 2678400001.4999995
Voy
fonte