Skip to content
Tutorial Reference

Python Pandas: How to Fix "AttributeError: Can only use .dt accessor with datetimelike values"

Learn how to resolve the 'Can only use .dt accessor with datetimelike values' error in Pandas by converting string or object columns to datetime using pd.to_datetime() and proper date parsing techniques.

When working with date and time data in Pandas, the .dt accessor is an invaluable tool, providing convenient access to various datetime properties (like year, month, day, hour) and methods for Series that contain datetime-like values. However, a common stumbling block is the AttributeError: Can only use .dt accessor with datetimelike values. This error clearly indicates that you're attempting to use .dt on a Pandas Series whose data type is not actually a datetime type (e.g., it might be object if it contains strings, or even numeric).

This guide will thoroughly explain why this AttributeError occurs, demonstrate how to reproduce it, and provide robust solutions, primarily focusing on correctly converting your column to a proper datetime type using pd.to_datetime() and ensuring correct parsing during CSV import with parse_dates.

Understanding the Error: The .dt Accessor and Datetimelike Requirement

In Pandas, when a Series has a datetime64[ns] data type (or a Period or Timedelta type, though datetime64[ns] is most common for this error), you can use the .dt accessor to easily extract components or perform datetime-specific operations. For example:

  • my_datetime_series.dt.year
  • my_datetime_series.dt.month_name()
  • my_datetime_series.dt.dayofweek
  • my_datetime_series.dt.strftime('%Y-%m-%d')

The AttributeError: Can only use .dt accessor with datetimelike values arises when the Series you are trying to use .dt on does not have a datetimelike dtype. Most often, it's an object dtype because the column contains strings that look like dates but haven't yet been converted by Pandas into actual datetime objects.

Reproducing the Error: Attempting .dt on a Non-Datetime Column

Let's create a DataFrame where a 'date_str' column holds date-like strings.

import pandas as pd

df = pd.DataFrame({
    'event_name': ['Meeting A', 'Workshop B', 'Conference C', 'Webinar D'],
    'organizer': ['Org1', 'Org2', 'Org1', 'Org3'],
    'date_str': ['2023-11-15', '2023-12-01', '2024-01-20', '2024-02-10'] # Strings, not datetime objects
})

print("Original DataFrame:")
print(df)
print()
print(f"dtype of 'date_str' column: {df['date_str'].dtype}\n")

try:
    years = df['date_str'].dt.year
    print(years)
except AttributeError as e:
    print(f"Error: {e}")

Output:

Original DataFrame:
     event_name organizer    date_str
0     Meeting A      Org1  2023-11-15
1    Workshop B      Org2  2023-12-01
2  Conference C      Org1  2024-01-20
3     Webinar D      Org3  2024-02-10

dtype of 'date_str' column: object

Error: Can only use .dt accessor with datetimelike values

Solution 1: Convert Column to Datetime using pd.to_datetime() (Most Common Fix)

The primary solution is to explicitly convert the column containing date-like strings (or other coercible types) into a proper Pandas datetime Series using pd.to_datetime(). Once converted, the .dt accessor will be available.

Basic Conversion

import pandas as pd

df = pd.DataFrame({
    'event_name': ['Meeting A', 'Workshop B', 'Conference C', 'Webinar D'],
    'organizer': ['Org1', 'Org2', 'Org1', 'Org3'],
    'date_str': ['2023-11-15', '2023-12-01', '2024-01-20', '2024-02-10'] # Strings, not datetime objects
})

df['date_dt'] = pd.to_datetime(df['date_str'])

print("DataFrame after converting 'date_str' to 'date_dt':")
print(df)
print(f"dtype of 'date_dt' column: {df['date_dt'].dtype}\n") # Output: datetime64[ns]

years_correct = df['date_dt'].dt.year
print("Extracted years:")
print(years_correct)

Output:

DataFrame after converting 'date_str' to 'date_dt':
     event_name organizer    date_str    date_dt
0     Meeting A      Org1  2023-11-15 2023-11-15
1    Workshop B      Org2  2023-12-01 2023-12-01
2  Conference C      Org1  2024-01-20 2024-01-20
3     Webinar D      Org3  2024-02-10 2024-02-10
dtype of 'date_dt' column: datetime64[ns]

Extracted years:
0    2023
1    2023
2    2024
3    2024
Name: date_dt, dtype: int32

It's common to overwrite the original string column: df['date_str'] = pd.to_datetime(df['date_str']).

Handling Parsing Errors with errors='coerce'

If your date column might contain strings that can not be parsed into valid dates (e.g., "Unknown", "N/A", or malformed dates like "2023-02-30"), pd.to_datetime() will raise an error by default. To handle this gracefully, use errors='coerce', which will convert unparseable strings to NaT (Not a Time).

import pandas as pd

df_with_invalid_dates = pd.DataFrame({
    'report_date': ['2023-05-10', '2023-06-31', 'Invalid Date', '2023-07-05']
})

df_with_invalid_dates['report_date_dt'] = pd.to_datetime(
    df_with_invalid_dates['report_date'],
    errors='coerce' # Invalid dates become NaT
)
print("DataFrame with coerced invalid dates:")
print(df_with_invalid_dates)
print()

months = df_with_invalid_dates['report_date_dt'].dt.month
print("Extracted months (NaT becomes NaN for numeric properties):")
print(months)

Output:

DataFrame with coerced invalid dates:
    report_date report_date_dt
0    2023-05-10     2023-05-10
1    2023-06-31            NaT
2  Invalid Date            NaT
3    2023-07-05     2023-07-05

Extracted months (NaT becomes NaN for numeric properties):
0    5.0
1    NaN
2    NaN
3    7.0
Name: report_date_dt, dtype: float64

Specifying Date Formats with format for pd.to_datetime()

If your date strings are in a non-standard format that Pandas can not automatically infer, you must provide a format string to pd.to_datetime() to tell it how to parse the strings.

import pandas as pd

df_custom_format = pd.DataFrame({
    'log_timestamp': ['25/01/2023 10:30', '15/02/2023 11:45', '10/03/2023 09:00'] # DD/MM/YYYY HH:MM
})

df_custom_format['log_datetime'] = pd.to_datetime(
    df_custom_format['log_timestamp'],
    format='%d/%m/%Y %H:%M', # Matches the string format
    errors='coerce'
)
print("DataFrame with custom format parsed to datetime:")
print(df_custom_format)
print(f"dtype of 'log_datetime': {df_custom_format['log_datetime'].dtype}\n")

print("Hours extracted:")
print(df_custom_format['log_datetime'].dt.hour)

Output:

DataFrame with custom format parsed to datetime:
      log_timestamp        log_datetime
0  25/01/2023 10:30 2023-01-25 10:30:00
1  15/02/2023 11:45 2023-02-15 11:45:00
2  10/03/2023 09:00 2023-03-10 09:00:00
dtype of 'log_datetime': datetime64[ns]

Hours extracted:
0    10
1    11
2     9
Name: log_datetime, dtype: int32

Note on utc=True

If your input datetime strings represent times in different timezones and you want to convert them all to a consistent UTC timezone-aware datetime, you can use utc=True in pd.to_datetime(). The .dt accessor works on timezone-aware datetimes as well. df['date_utc'] = pd.to_datetime(df['date_str'], errors='coerce', utc=True)

Solution 2: Ensuring Correct Parsing During CSV Import with parse_dates**

If you are reading your data from a CSV file, you can instruct pd.read_csv() to attempt to parse specific columns as dates during the import process itself using the parse_dates argument.

events.csv example:

EventName,StartDate,Category
Alpha Launch,2023-01-15,Tech
Beta Release,2023-02-28,Product
Gamma Review,2023-03-10,Internal
import pandas as pd

file_path = 'events.csv'

df_from_csv = pd.read_csv(file_path, parse_dates=['StartDate'])

print("DataFrame read from CSV with 'StartDate' parsed as datetime:")
print(df_from_csv)
print(f"dtype of 'StartDate' column: {df_from_csv['StartDate'].dtype}\n") # datetime64[ns]

start_days = df_from_csv['StartDate'].dt.day
print("Start days extracted:")
print(start_days)

Output:

DataFrame read from CSV with 'StartDate' parsed as datetime:
      EventName  StartDate  Category
0  Alpha Launch 2023-01-15      Tech
1  Beta Release 2023-02-28   Product
2  Gamma Review 2023-03-10  Internal
dtype of 'StartDate' column: datetime64[ns]

Start days extracted:
0    15
1    28
2    10
Name: StartDate, dtype: int32

If parse_dates encounters values it can not convert, it will typically leave them as strings (object dtype) for that specific cell, or raise an error depending on the data, unless errors='coerce' is also handled implicitly or explicitly if you were to use pd.to_datetime after reading. For robust parsing with parse_dates for non-standard formats, you often combine it with a custom date parser function passed to date_parser or by post-processing with pd.to_datetime(df['col'], format='...').

Example: Creating a New Column with a Datetime Component (e.g., Year)

Once your date column is correctly typed as datetime64[ns], using .dt to create new feature columns is straightforward.

import pandas as pd

df = pd.DataFrame({
    'event_name': ['Meeting A', 'Workshop B', 'Conference C', 'Webinar D'],
    'organizer': ['Org1', 'Org2', 'Org1', 'Org3'],
    'date_str': ['2023-11-15', '2023-12-01', '2024-01-20', '2024-02-10'] # Strings, not datetime objects
})
df['date_dt'] = pd.to_datetime(df['date_str'])


df['event_year'] = df['date_dt'].dt.year

df['event_month_name'] = df['date_dt'].dt.month_name()

print("DataFrame with new year and month name columns:")
print(df[['date_dt', 'event_year', 'event_month_name']])

Output:

DataFrame with new year and month name columns:
     date_dt  event_year event_month_name
0 2023-11-15        2023         November
1 2023-12-01        2023         December
2 2024-01-20        2024          January
3 2024-02-10        2024         February

Conclusion

The AttributeError: Can only use .dt accessor with datetimelike values is a clear message from Pandas: your Series isn't in a datetime format. The primary solution is to convert the target column to a datetime type using pd.to_datetime().

  • Remember to handle potential parsing errors with errors='coerce'.
  • Specify the format if your date strings are non-standard.
  • Alternatively, use the parse_dates argument in pd.read_csv() during data import.

Once your Series has a datetime64[ns] (or similar datetimelike) dtype, the .dt accessor will unlock a wealth of convenient properties and methods for your time-series analysis.

Navigation