Pandas: Making use of DataFrame.at_time() method

Updated: February 20, 2024 By: Guest Contributor Post a comment


Pandas is a widely used library in the Python programming language, especially for data manipulation and analysis. One of its core structures is the DataFrame, which can be thought of as a two-dimensional, size-mutable, and potentially heterogeneous tabular data structure with labeled axes (rows and columns). In this tutorial, we will delve into understanding and utilizing the at_time() method of the DataFrame, which is especially useful in dealing with datetime data.

The at_time() method is used to select rows at a particular time of the day. This is particularly handy when working with time series data, allowing the user to easily extract records at a specific time across different dates.

Setting Up Your Environment

Before we dive into the examples, ensure you have the Pandas library installed:

pip install pandas

Additionally, for some examples that involve datetime handling, you might also want to install the pytz library for time zone handling:

pip install pytz

Basic Usage of at_time()

Let’s start with the basics. Suppose you have a DataFrame containing datetime information and you want to extract all rows that fall at a particular time of the day. First, let’s create a simple DataFrame:

import pandas as pd
import numpy as np

dates = pd.date_range('2023-01-01', periods=7)
data = np.random.randn(7, 2)
df = pd.DataFrame(data, index=dates, columns=['A', 'B'])

Here, we have a DataFrame df with random values and dates between January 1st and January 7th, 2023 as its index. To select rows at 00:00 hours, you can use:

result = df.at_time('00:00')

You’ll note that all rows in the DataFrame that have 00:00 times are returned. If your DataFrame does not contain any rows at that time, the result will be an empty DataFrame.

Handling More Complex Scenarios

Now let’s introduce more complex scenarios. Suppose your DataFrame’s index contains more detailed datetime information, including the time of day:

dates = pd.date_range('2023-01-01 08:00', periods=7, freq='H')
data = np.random.randn(7, 2)
df = pd.DataFrame(data, index=dates, columns=['A', 'B'])

To extract all rows at 9:00 AM, you would:

result = df.at_time('09:00')

In this case, df.at_time('09:00') fetches the row(s) whose index falls at 9:00 AM on any day within the DataFrame. This demonstrates how at_time() is adept at slicing time series data to get the exact moments you’re interested in.

Working with Time Zones

Time zones can complicate datetime handling significantly. Thankfully, Pandas offers robust support for time zone aware datetimes. First, let’s make our DataFrame time zone aware:

dates = dates.tz_localize('UTC').tz_convert('America/New_York')
data = np.random.randn(7, 2)
df = pd.DataFrame(data, index=dates, columns=['A', 'B'])

Now, if you want to select rows at 9:00 AM EST, you do:

result = df.at_time('09:00')

This process ensures that the at_time() method respects the time zone of the datetime index, allowing for accurate selection of data across different time zones.

Advanced Use Cases

For more advanced use cases, imagine a scenario where your DataFrame spans multiple days and contains time-stamped data at irregular intervals. You might be interested in analyzing data only at certain times of the day across this period. The at_time() method simplifies this analysis by enabling direct access to these slices.

Another advanced scenario could involve combining at_time() with other slicing/filtering methods to perform complex queries on your dataset. For example, extracting all data points at 9:00 AM that also meet certain conditionals on other columns of the DataFrame.


The at_time() method is a powerful tool in Pandas for selecting rows based on the time part of a datetime index. This guide has shown you how to use it from the basic to more advanced scenarios, including dealing with time zones. Whether you’re handling simple time series data or performing complex temporal analyses, at_time() can simplify the process and make your Python data manipulation tasks more efficient.