如何在python中找到两个datetime对象之间的时间差?

只要用一个减去另一个。你会得到一个不同的timedelta对象。

>>> import datetime
>>> d1 = datetime.datetime.now()
>>> d2 = datetime.datetime.now() # after a 5-second or so pause
>>> d2 - d1
datetime.timedelta(0, 5, 203000)
>>> dd = d2 - d1
>>> print (dd.days) # get days
>>> print (dd.seconds) # get seconds
>>> print (dd.microseconds) # get microseconds
>>> print (int(round(dd.total_seconds()/60, 0))) # get minutes

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

Python 2.7新增了timedelta实例方法.total_seconds()。在Python文档中，这相当于(td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / 10**6。

参考:# EYZ0

>>> 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

这就是我如何获得两个datetime之间经过的小时数。datetime对象:

before = datetime.datetime.now()
after  = datetime.datetime.now()
hours  = math.floor(((after - before).seconds) / 3600)

使用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)

这是我使用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

如果a， b是datetime对象，那么在Python 3中查找它们之间的时间差:

from datetime import timedelta


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

在早期的Python版本中:

time_difference_in_minutes = time_difference.total_seconds() / 60

如果a， b是naive datetime对象，例如由datetime.now()返回，那么如果对象表示具有不同UTC偏移量的本地时间，例如DST转换前后或过去/未来日期，则结果可能是错误的。更多细节:查找日期时间之间是否已经过了24小时- Python。

要获得可靠的结果，请使用UTC时间或时区感知的datetime对象。

要查找天数:timedelta有一个'days'属性。你可以简单地查询一下。

>>>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

只是认为在timedelta方面提到格式化可能是有用的。Strptime()根据格式解析表示时间的字符串。

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)

以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

持续时间(年)

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

持续时间(天)

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

持续时间(小时)

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

持续时间(分钟)

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

持续时间(秒)

[!参见本文底部关于使用持续时间以秒为单位的警告

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

持续时间(微秒)

[!参见本文底部关于使用以微秒为单位的持续时间的警告

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

两个日期之间的总时间

>>> 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]))

或者仅仅是:

>>> print(now - then)

<强>编辑2019 由于这个答案已经获得了支持，我将添加一个函数，这可能会简化一些

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

如果timedelta大于返回值的最大值，则应该谨慎使用。

例子:

end为start后1h和200μs:

>>> start = datetime(2020,12,31,22,0,0,500)
>>> end = datetime(2020,12,31,23,0,0,700)
>>> delta = end - start
>>> delta.microseconds
RESULT: 200
EXPECTED: 3600000200

end在start之后是1d和1h:

>>> start = datetime(2020,12,30,22,0,0)
>>> end = datetime(2020,12,31,23,0,0)
>>> delta = end - start
>>> delta.seconds
RESULT: 3600
EXPECTED: 90000

用其他方法得到日期之间的差异;

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)

得到最小值的输出。

谢谢

我用的是这样的:

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

这是为了找出当前时间和上午9:30之间的差值

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

我利用时差进行了连续集成测试，以检查和完善我的功能。如果有人需要，这里有一些简单的代码

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()

使用:

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')

我在log输出中有类似的东西

2019-12-20 17:19:23.635297 tl -----------> 0.00007
2019-12-20 17:19:28.147656 tl -----------> 4.51234   Tests finished

基于@Attaque great 回答，我建议一个更短的简化版本的日期时间差计算器:

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]

我改变了它，以避免声明重复的函数，删除了漂亮的打印默认间隔，并增加了对毫秒、周和ISO月的支持(简单地说，月份只是一个近似，基于每个月都等于365/12的假设)。

生产:

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

要获得hour， minute和second，您可以这样做

>>> import datetime
>>> first_time = datetime.datetime.now()
>>> later_time = datetime.datetime.now()
>>> difference = later_time - first_time
>>> m, s = divmod(difference.total_seconds(), 60)
>>> print("H:M:S is {}:{}:{}".format(m//60, m%60, s))

你可能会发现这个快速的片段在不那么长的时间间隔里很有用:

    from datetime import datetime as dttm
time_ago = dttm(2017, 3, 1, 1, 1, 1, 1348)
delta = dttm.now() - time_ago
days = delta.days # can be converted into years which complicates a bit…
hours, minutes, seconds = map(int, delta.__format__('').split('.')[0].split(' ')[-1].split(':'))

在Python v.3.8.6上测试

这将给出以秒为单位的差值(然后除以60得到分钟):

import time
import datetime


t_start = datetime.datetime.now()


time.sleep(10)


t_end = datetime.datetime.now()
elapsedTime = (t_end - t_start )


print(elapsedTime.total_seconds())

输出:

10.009222

在我看来，这是最简单的方法，您不需要担心精度或溢出问题。

例如，使用elapsedTime.seconds会损失很多精度(它返回一个整数)。此外，elapsedTime.microseconds的上限是10^6，正如这个答案指出的那样。因此，例如，在10秒内sleep()， elapsedTime.microseconds给出8325(即错误的，应该在10,000,000左右)。

import datetime
date = datetime.date(1, 1, 1)
#combine a dummy date to the time
datetime1 = datetime.datetime.combine(date, start_time)
datetime2 = datetime.datetime.combine(date, stop_time)
#compute the difference
time_elapsed = datetime1 - datetime2

我们不能直接减去datetime。时间对象
因此我们需要给它添加一个随机日期(我们使用combine)
或者你可以用“today"而不是(1,1,1)

希望这能有所帮助

这里有一个很容易概括或转化为函数的答案，它合理紧凑，易于遵循。

ts_start=datetime(2020, 12, 1, 3, 9, 45)
ts_end=datetime.now()
ts_diff=ts_end-ts_start
secs=ts_diff.total_seconds()
days,secs=divmod(secs,secs_per_day:=60*60*24)
hrs,secs=divmod(secs,secs_per_hr:=60*60)
mins,secs=divmod(secs,secs_per_min:=60)
secs=round(secs, 2)
answer='Duration={} days, {} hrs, {} mins and {} secs'.format(int(days),int(hrs),int(mins),secs)
print(answer)

它以Duration=270 days, 10 hrs, 32 mins and 42.13 secs的形式给出答案

这可能会帮助一些人，用这个方法找到过期与否其计算天数。还有dt.seconds和dt.microseconds可供选择

from datetime import datetime
# updated_at = "2022-10-20T07:18:56.950563"
def is_expired(updated_at):
expires_in = 7 #days
datetime_format = '%Y-%m-%dT%H:%M:%S.%f'
time_difference = datetime.now() - datetime.strptime(updated_at, datetime_format)


return True if time_difference.days > expires_in else False