How do I tell the time difference in minutes between two `datetime`

objects?

# How do I find the time difference between two datetime objects in python?

## The Question :

*395 people think this question is useful*

*The Question Comments :*

## The Answer 1

*407 people think this answer is useful*

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

Subtracting the later time from the first time `difference = later_time - first_time`

creates a datetime object that only holds the difference.
In the example above it is 0 minutes, 8 seconds and 562000 microseconds.

## The Answer 2

*159 people think this answer is useful*

New at Python 2.7 is the `timedelta`

instance method `.total_seconds()`

. From the Python docs, this is equivalent to `(td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / 10**6`

.

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

## The Answer 3

*135 people think this answer is useful*

**Using datetime example**

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

**Duration in years**

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

**Duration in days**

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

**Duration in hours**

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

**Duration in minutes**

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

**Duration in seconds**

*[!] See warning about using duration in seconds in the bottom of this post*

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

**Duration in microseconds**

*[!] See warning about using duration in microseconds in the bottom of this post*

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

**Total duration between the two dates**

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

or simply:

>>> print(now - then)

**Edit 2019**
Since this answer has gained traction, I’ll add a function, which might simplify the usage for some

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

**Warning: Caveat about built-in .seconds and .microseconds**

`datetime.seconds`

and `datetime.microseconds`

are capped to [0,86400) and [0,10^6) respectively.

They should be used carefully if timedelta is bigger than the max returned value.

Examples:

`end`

is 1h and 200μs after `start`

:

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

is 1d and 1h after `start`

:

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

## The Answer 4

*30 people think this answer is useful*

Just subtract one from the other. You get a `timedelta`

object with the difference.

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

You can convert `dd.days`

, `dd.seconds`

and `dd.microseconds`

to minutes.

## The Answer 5

*26 people think this answer is useful*

If `a`

, `b`

are datetime objects then to find the time difference between them in Python 3:

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

On earlier Python versions:

time_difference_in_minutes = time_difference.total_seconds() / 60

If `a`

, `b`

are naive datetime objects such as returned by `datetime.now()`

then the result may be wrong if the objects represent local time with different UTC offsets e.g., around DST transitions or for past/future dates. More details: Find if 24 hrs have passed between datetimes – Python.

To get reliable results, use UTC time or timezone-aware datetime objects.

## The Answer 6

*18 people think this answer is useful*

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)

## The Answer 7

*11 people think this answer is useful*

This is how I get the number of hours that elapsed between two datetime.datetime objects:

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

## The Answer 8

*9 people think this answer is useful*

To just find the number of days: timedelta has a ‘days’ attribute. You can simply query that.

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

## The Answer 9

*7 people think this answer is useful*

Just thought it might be useful to mention formatting as well in regards to timedelta. strptime() parses a string representing a time according to a format.

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)

This will output: 0:05:00.518000

## The Answer 10

*3 people think this answer is useful*

I use somethign like this :

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

## The Answer 11

*2 people think this answer is useful*

this is to find the difference between current time and 9.30 am

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

## The Answer 12

*1 people think this answer is useful*

This is my approach using 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

## The Answer 13

*1 people think this answer is useful*

In Other ways to get difference between date;

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)

So get output in Min.

Thanks

## The Answer 14

*1 people think this answer is useful*

I have used time differences for continuous integration tests to check and improve my functions. Here is simple code if somebody need it

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

Using:

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

and i have something like that in log output

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

## The Answer 15

*1 people think this answer is useful*

Based on @Attaque great answer, I propose a shorter simplified version of the datetime difference calculator:

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]

I’ve changed it to avoid declaring repetetive functions, removed the pretty print default interval and added support for milliseconds, weeks and ISO months (bare in mind months are just approximate, based on assumption that each month is equal to `365/12`

).

Which produces:

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

## The Answer 16

*1 people think this answer is useful*

To get the `hour`

, `minute`

and `second`

, you can do this

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

## The Answer 17

*0 people think this answer is useful*

You may find this fast snippet useful in not so much long time intervals:

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

tested on Python v.3.8.6