# What is the standard way to add N seconds to datetime.time in Python?

## Question:

Given a `datetime.time` value in Python, is there a standard way to add an integer number of seconds to it, so that `11:34:59` + 3 = `11:35:02`, for example?

These obvious ideas don’t work:

``````>>> datetime.time(11, 34, 59) + 3
TypeError: unsupported operand type(s) for +: 'datetime.time' and 'int'
>>> datetime.time(11, 34, 59) + datetime.timedelta(0, 3)
TypeError: unsupported operand type(s) for +: 'datetime.time' and 'datetime.timedelta'
>>> datetime.time(11, 34, 59) + datetime.time(0, 0, 3)
TypeError: unsupported operand type(s) for +: 'datetime.time' and 'datetime.time'
``````

In the end I have written functions like this:

``````def add_secs_to_time(timeval, secs_to_add):
secs = timeval.hour * 3600 + timeval.minute * 60 + timeval.second
return datetime.time(secs // 3600, (secs % 3600) // 60, secs % 60)
``````

I can’t help thinking that I’m missing an easier way to do this though.

### Related

Try adding a `datetime.datetime` to a `datetime.timedelta`. If you only want the time portion, you can call the `time()` method on the resultant `datetime.datetime` object to get it.

You can use full `datetime` variables with `timedelta`, and by providing a dummy date then using `time` to just get the time value.

For example:

``````import datetime
a = datetime.datetime(100,1,1,11,34,59)
b = a + datetime.timedelta(0,3) # days, seconds, then other fields.
print(a.time())
print(b.time())
``````

results in the two values, three seconds apart:

``````11:34:59
11:35:02
``````

You could also opt for the more readable

``````b = a + datetime.timedelta(seconds=3)
``````

if you’re so inclined.

If you’re after a function that can do this, you can look into using `addSecs` below:

``````import datetime

fulldate = datetime.datetime(100, 1, 1, tm.hour, tm.minute, tm.second)
fulldate = fulldate + datetime.timedelta(seconds=secs)
return fulldate.time()

a = datetime.datetime.now().time()
b = addSecs(a, 300)
print(a)
print(b)
``````

This outputs:

`````` 09:11:55.775695
09:16:55
``````

One little thing, might add clarity to override the default value for seconds

``````>>> b = a + datetime.timedelta(seconds=3000)
>>> b
datetime.datetime(1, 1, 1, 12, 24, 59)
``````

Thanks to @Pax Diablo, @bvmou and @Arachnid for the suggestion of using full datetimes throughout. If I have to accept datetime.time objects from an external source, then this seems to be an alternative `add_secs_to_time()` function:

``````def add_secs_to_time(timeval, secs_to_add):
dummy_date = datetime.date(1, 1, 1)
full_datetime = datetime.datetime.combine(dummy_date, timeval)
``````

This verbose code can be compressed to this one-liner:

``````(datetime.datetime.combine(datetime.date(1, 1, 1), timeval) + datetime.timedelta(seconds=secs_to_add)).time()
``````

but I think I’d want to wrap that up in a function for code clarity anyway.

As others here have stated, you can just use full datetime objects throughout:

``````from datetime import datetime, date, time, timedelta
sometime = time(8,00) # 8am
later = (datetime.combine(date.today(), sometime) + timedelta(seconds=3)).time()
``````

However, I think it’s worth explaining why full datetime objects are required. Consider what would happen if I added 2 hours to 11pm. What’s the correct behavior? An exception, because you can’t have a time larger than 11:59pm? Should it wrap back around?

Different programmers will expect different things, so whichever result they picked would surprise a lot of people. Worse yet, programmers would write code that worked just fine when they tested it initially, and then have it break later by doing something unexpected. This is very bad, which is why you’re not allowed to add timedelta objects to time objects.

If it’s worth adding another file / dependency to your project, I’ve just written a tiny little class that extends `datetime.time` with the ability to do arithmetic. When you go past midnight, it wraps around zero. Now, “What time will it be, 24 hours from now” has a lot of corner cases, including daylight savings time, leap seconds, historical timezone changes, and so on. But sometimes you really do need the simple case, and that’s what this will do.

Your example would be written:

``````>>> import datetime
>>> import nptime
>>> nptime.nptime(11, 34, 59) + datetime.timedelta(0, 3)
nptime(11, 35, 2)
``````

`nptime` inherits from `datetime.time`, so any of those methods should be usable, too.

It’s available from PyPi as `nptime` (“non-pedantic time”), or on GitHub: https://github.com/tgs/nptime

For completeness’ sake, here’s the way to do it with `arrow` (better dates and times for Python):

``````sometime = arrow.now()
abitlater = sometime.shift(seconds=3)
``````

You cannot simply add number to `datetime` because it’s unclear what unit is used: seconds, hours, weeks…

There is `timedelta` class for manipulations with date and time. `datetime` minus `datetime` gives `timedelta`, `datetime` plus `timedelta` gives `datetime`, two `datetime` objects cannot be added although two `timedelta` can.

Create `timedelta` object with how many seconds you want to add and add it to `datetime` object:

``````>>> from datetime import datetime, timedelta
>>> t = datetime.now() + timedelta(seconds=3000)
>>> print(t)
datetime.datetime(2018, 1, 17, 21, 47, 13, 90244)
``````

There is same concept in C++: `std::chrono::duration`.

Old question, but I figured I’d throw in a function that handles timezones. The key parts are passing the `datetime.time` object’s `tzinfo` attribute into combine, and then using `timetz()` instead of `time()` on the resulting dummy datetime. This answer partly inspired by the other answers here.

``````def add_timedelta_to_time(t, td):
"""Add a timedelta object to a time object using a dummy datetime.

:param t: datetime.time object.
:param td: datetime.timedelta object.

:returns: datetime.time object, representing the result of t + td.

NOTE: Using a gigantic td may result in an overflow. You've been
warned.
"""
# Create a dummy date object.
dummy_date = date(year=100, month=1, day=1)

# Combine the dummy date with the given time.
dummy_datetime = datetime.combine(date=dummy_date, time=t, tzinfo=t.tzinfo)

# Add the timedelta to the dummy datetime.
new_datetime = dummy_datetime + td

# Return the resulting time, including timezone information.
return new_datetime.timetz()
``````

And here’s a really simple test case class (using built-in `unittest`):

``````import unittest
from datetime import datetime, timezone, timedelta, time

def test_wraps(self):
t = time(hour=23, minute=59)
td = timedelta(minutes=2)
t_expected = time(hour=0, minute=1)
t_actual = add_timedelta_to_time(t=t, td=td)
self.assertEqual(t_expected, t_actual)

def test_tz(self):
t = time(hour=4, minute=16, tzinfo=timezone.utc)
td = timedelta(hours=10, minutes=4)
t_expected = time(hour=14, minute=20, tzinfo=timezone.utc)
t_actual = add_timedelta_to_time(t=t, td=td)
self.assertEqual(t_expected, t_actual)

if __name__ == '__main__':
unittest.main()
``````

In a real world environment it’s never a good idea to work solely with `time`, always use `datetime`, even better `utc`, to avoid conflicts like overnight, daylight saving, different timezones between user and server etc.

So I’d recommend this approach:

``````import datetime as dt

_now = dt.datetime.now()  # or dt.datetime.now(dt.timezone.utc)
_in_5_sec = _now + dt.timedelta(seconds=5)

# get '14:39:57':
_in_5_sec.strftime('%H:%M:%S')
``````

If you don’t already have a timedelta object, another possibility would be to just initialize a new time object instead with the attributes of the old one and add values where needed:

``````   new_time:time = time(
hour=curr_time.hour + n_hours,
minute=curr_time.minute + n_minutes,
seconds=curr_time.second + n_seconds
)
``````

Admittedly this only works if you make a few assumptions about your values, since overflow is not handled here. But I just thought it was worth to keep this in mind
as it can save a line or two

Categories: questions Tags: , , ,
Answers are sorted by their score. The answer accepted by the question owner as the best is marked with
at the top-right corner.