5 Best Ways to Round Timedelta to the Nearest Hour with Python Pandas

by

💡 Problem Formulation: Working with timeseries data often requires rounding time intervals to a common frequency for standardization and comparison. Specifically, you might have a pandas Series or DataFrame with timedelta objects that you want to round to the nearest hour. For example, given a timedelta of ‘2 hours 36 minutes’, you’d want to round it to ‘3 hours’. This article demonstrates five different methods to achieve this in Python using pandas.

Method 1: Using dt.round() function

The dt.round() function is used to round the time to the nearest specified frequency. When applied to a Series or DataFrame column of timedeltas, it can round each value to the desired frequency, such as ‘H’ for hour.

Here’s an example:

import pandas as pd

# Creating a Timedelta Series
td_series = pd.Series(pd.to_timedelta(['02:36:00', '01:49:00', '05:25:30']))
rounded_series = td_series.dt.round('H')

print(rounded_series)

Output:

0   03:00:00
1   02:00:00
2   05:00:00
dtype: timedelta64[ns]

This code snippet creates a pandas Series from a list of time strings, converts them to timedeltas using pd.to_timedelta(), and uses the round() method with the ‘H’ argument to round them to the nearest hour.

Method 2: Combining np.timedelta64() and np.round()

Numpy’s np.timedelta64() can represent timedelta values, and when combined with np.round(), it allows rounding to the nearest hour, by first converting timedeltas to hours, applying rounding, and then converting back to timedeltas.

Here’s an example:

import pandas as pd
import numpy as np

td_series = pd.Series(pd.to_timedelta(['02:36:00', '01:49:00', '05:25:30']))
rounded_series = td_series / np.timedelta64(1, 'h')
rounded_series = pd.to_timedelta(np.round(rounded_series), unit='h')

print(rounded_series)

Output:

0   03:00:00
1   02:00:00
2   05:00:00
dtype: timedelta64[ns]

By dividing the timedelta by np.timedelta64(1, 'h'), we convert our timedeltas into floating point numbers representing hours. After rounding these numbers using np.round(), we convert them back to timedeltas with pd.to_timedelta(). This approach provides greater control and can be adapted for other units of time easily.

Method 3: Applying Python’s built-in round() method

Python’s built-in round() function can round numbers to a given precision. By converting pandas timedeltas to total seconds, rounding to the nearest number of seconds in an hour, and converting back, we can achieve our goal.

Here’s an example:

import pandas as pd

td_series = pd.Series(pd.to_timedelta(['02:36:00', '01:49:00', '05:25:30']))
rounded_seconds = round(td_series.dt.total_seconds() / 3600) * 3600
rounded_series = pd.to_timedelta(rounded_seconds, unit='s')

print(rounded_series)

Output:

0   03:00:00
1   02:00:00
2   05:00:00
dtype: timedelta64[ns]

We use Series.dt.total_seconds() to convert timedeltas to seconds and then round to the nearest hour by dividing and multiplying by 3600, the number of seconds in an hour. pd.to_timedelta() is then used to convert the rounded seconds back to timedelta format.

Method 4: Using Series.apply() with a Custom Function

For complex rounding logic or additional processing, apply() with a custom function gives you the flexibility to define exactly how each timedelta should be rounded.

Here’s an example:

import pandas as pd

def custom_round(td):
    hour = td.components.hours
    if td.components.minutes >= 30:
        hour += 1
    return pd.Timedelta(hours=hour)

td_series = pd.Series(pd.to_timedelta(['02:36:00', '01:49:00', '05:25:30']))
rounded_series = td_series.apply(custom_round)

print(rounded_series)

Output:

0   03:00:00
1   02:00:00
2   05:00:00
dtype: timedelta64[ns]

This example defines a function custom_round() that adds an hour if the minutes component is 30 or more. Each timedelta value in the series is then processed through this function using apply().

Bonus One-Liner Method 5: Using Series.dt.ceil() or Series.dt.floor()

These functions are helpful when you need to always round up or down to the nearest hour which can be particularly useful in billing and scheduling applications.

Here’s an example:

import pandas as pd

# Rounding up to the nearest hour
td_series = pd.Series(pd.to_timedelta(['02:36:00', '01:49:00', '05:25:30']))
rounded_up_series = td_series.dt.ceil('H')
print(rounded_up_series)

# Rounding down to the nearest hour
rounded_down_series = td_series.dt.floor('H')
print(rounded_down_series)

Output:

0   03:00:00
1   02:00:00
2   06:00:00
dtype: timedelta64[ns]

0   02:00:00
1   01:00:00
2   05:00:00
dtype: timedelta64[ns]

This quick method leverages pandas’ built-in functions ceil() and floor() to always round up or down to the nearest hour, respectively.

Summary/Discussion

  • Method 1: Using dt.round(). This method is simple and concise, making it perfect for quick tasks but less flexible for edge cases or custom rounding logic.
  • Method 2: Combining np.timedelta64() and np.round(). This method offers a higher degree of control and adaptability for different time units, which can be an advantage in more complex scenarios.
  • Method 3: Applying Python’s built-in round(). This approach is versatile and programming-language-agnostic, but may require additional steps for non-hourly rounding.
  • Method 4: Using Series.apply() with a Custom Function. Best for complex conditions and custom rounding, but potentially less performant for large datasets.
  • Method 5: Using Series.dt.ceil() or Series.dt.floor(). Great for consistently rounding up or down; however, there’s no middle-ground rounding option like round().