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

Posted on

Solving problem is about exposing yourself to as many situations as possible like How do I find the time difference between two datetime objects in python? and practice these strategies over and over. With time, it becomes second nature and a natural way you approach any problems in general. Big or small, always start with a plan, use other strategies mentioned here till you are confident and ready to code the solution.
In this post, my aim is to share an overview the topic about How do I find the time difference between two datetime objects in python?, which can be followed any time. Take easy to follow this discuss.

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

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

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

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

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

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)    # 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)       # Seconds in a day = 86400
``````

Duration in hours

``````>>> hours = divmod(duration_in_s, 3600)        # Seconds in an hour = 3600
``````

Duration in minutes

``````>>> minutes = divmod(duration_in_s, 60)        # 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 !)
>>> hours   = divmod(days, 3600)               # Use remainder of days to calc hours
>>> minutes = divmod(hours, 60)                # Use remainder of hours to calc minutes
>>> seconds = divmod(minutes, 1)               # Use remainder of minutes to calc seconds
>>> print("Time between dates: %d days, %d hours, %d minutes and %d seconds" % (days, hours, minutes, seconds))
``````

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) # Use remainder to calculate next variable
h = hours(d)
m = minutes(h)
s = seconds(m)
return "Time between dates: {} years, {} days, {} hours, {} minutes and {} seconds".format(int(y), int(d), int(h), int(m), int(s))
return {
'years': int(years()),
'days': int(days()),
'hours': int(hours()),
'minutes': int(minutes()),
'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
``````

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.

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.

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,3600)  # hours
m = divmod(h,60)  # minutes
s = m  # seconds
print '%d days, %d hours, %d minutes, %d seconds' % (d,h,m,s)
``````

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

``````>>>from datetime import datetime, timedelta