How to Resolve Python Error "TypeError: '>' not supported between instances of 'datetime.datetime' and 'str'"

When working with dates and times in Python, comparing datetime objects is a common task (e.g., checking if one date is before or after another). However, attempting to directly compare a datetime.datetime object with a plain string using operators like >, <, >=, or <= will result in a TypeError: '>' not supported between instances of 'datetime.datetime' and 'str' (or similar, depending on the operator).

This guide explains why this type mismatch occurs during comparison and provides the standard solution using datetime.strptime() to ensure you are comparing compatible types.

Understanding the Error: Type Compatibility in Comparisons

Python's comparison operators (>, <, >=, <=, ==, !=) are defined to work between objects of compatible types. You can compare two numbers, two strings (lexicographically), or two datetime objects (chronologically). However, Python doesn't inherently know how to order a datetime object relative to an arbitrary string. Does "2024-10-27" come before or after the datetime object representing noon on that day? Python raises a TypeError because the comparison is undefined between these distinct types.

The Cause: Comparing datetime Objects and Strings

The error occurs when you use a comparison operator with a datetime.datetime object on one side and a str object on the other.

from datetime import datetime

now_datetime = datetime.now()       # A datetime object
date_string = "2025-01-01 12:00:00" # A string representation

print(f"Datetime object: {now_datetime} (Type: {type(now_datetime)})")
print(f"Date string: '{date_string}' (Type: {type(date_string)})")

try:
    is_future = date_string > now_datetime
    print(f"Is future? {is_future}")
except TypeError as e:
    print(e)

Output:

Datetime object: 2025-04-27 17:41:24.828735 (Type: <class 'datetime.datetime'>)
Date string: '2025-01-01 12:00:00' (Type: <class 'str'>)
'>' not supported between instances of 'str' and 'datetime.datetime'

Solution: Convert the String to a datetime Object using strptime()

The correct approach is to ensure both operands are datetime objects before comparison. Use the datetime.strptime() class method to parse the date string into a corresponding datetime object.

The strptime() Method

datetime.strptime(date_string, format_code) parses a string representing a date and time according to a specified format code.

• date_string: The input string containing the date/time information.
• format_code: A string composed of special directives (like %Y, %m, %d, %H, %M, %S) that must exactly match the structure of the date_string.

Example and Fix

from datetime import datetime

now_datetime = datetime.now()
date_string = "2025-01-01 12:00:00"
format_code = "%Y-%m-%d %H:%M:%S"

print(f"Original string: '{date_string}'")

try:
    future_datetime = datetime.strptime(date_string, format_code)
    print(f"Converted datetime: {future_datetime} (Type: {type(future_datetime)})")

    is_after = future_datetime > now_datetime
    print(f"\nIs '{date_string}' after now? {is_after}") # Output will depend on current time

    is_before = future_datetime < now_datetime
    print(f"Is '{date_string}' before now? {is_before}")

except ValueError as e:
    print(f"ValueError during strptime: Check if string '{date_string}' matches format '{format_code}'. Error: {e}")
except TypeError as e:
    print(f"TypeError during comparison (should not happen now): {e}")

Output:

Original string: '2025-01-01 12:00:00'
Converted datetime: 2025-01-01 12:00:00 (Type: <class 'datetime.datetime'>)

Is '2025-01-01 12:00:00' after now? False
Is '2025-01-01 12:00:00' before now? True

By converting the string to a datetime object, the comparison becomes a valid chronological check between two points in time.

Matching the Format Code

It is essential that the format_code string precisely mirrors the format of your date_string.

• If date_string is "01/Nov/2024 15:30", format_code must be "%d/%b/%Y %H:%M".
• If date_string is "20241027", format_code must be "%Y%m%d".

Refer to the Python strftime() and strptime() format codes documentation for a complete list of directives. Mismatched formats will raise a ValueError.

from datetime import datetime

date_string_alt = "27-Oct-2024_10:00:05"
format_code_alt = "%d-%b-%Y_%H:%M:%S" # Matches the string

dt_object_alt = datetime.strptime(date_string_alt, format_code_alt)
print(f"Parsed alternative format: {dt_object_alt}")

Output:

Parsed alternative format: 2024-10-27 10:00:05

Alternative (Incorrect for Chronological Comparison): Converting Datetime to String

You could convert the datetime object to a string using strftime() and then compare two strings. However, this is generally wrong for date/time comparisons. String comparison is lexicographical (alphabetical/character-by-character), not chronological.

from datetime import datetime

dt1 = datetime(2024, 1, 10) # Jan 10th
dt2 = datetime(2024, 5, 9)  # May 9th

str1 = dt1.strftime("%Y-%m-%d") # "2024-01-10"
str2 = dt2.strftime("%Y-%m-%d") # "2024-05-09"

print(f"String comparison ('{str1}' < '{str2}'): {str1 < str2}") # Output: True

str1_bad = dt1.strftime("%d-%m-%Y") # "10-01-2024"
str2_bad = dt2.strftime("%d-%m-%Y") # "09-05-2024"

print(f"Datetime comparison (dt1 < dt2): {dt1 < dt2}") # Output: True

print(f"Bad String comparison ('{str1_bad}' < '{str2_bad}'): {str1_bad < str2_bad}") # Output: False (Incorrect result!)

Output:

String comparison ('2024-01-10' < '2024-05-09'): True
Datetime comparison (dt1 < dt2): True
Bad String comparison ('10-01-2024' < '09-05-2024'): False

Unless you use a string format where lexicographical order perfectly matches chronological order (like YYYY-MM-DD HH:MM:SS), comparing strings will give incorrect results for date/time logic. Always convert strings to datetime objects for comparisons.

Debugging the Error (type())

When you encounter this TypeError:

1. Examine the comparison line (> , <, >=, <=).
2. Identify the variables/values on the left and right sides.
3. Print their types: print(type(left_operand)), print(type(right_operand)).
4. You will see one is <class 'datetime.datetime'> and the other is <class 'str'>, confirming the mismatch.
5. Apply Solution 3: Convert the string operand to a datetime object using strptime() with the correct format code.

Conclusion

The TypeError: '>' not supported between instances of 'datetime.datetime' and 'str' (and similar for other operators) occurs because Python can not perform chronological comparisons between a datetime object and a string.

The definitive solution is to ensure both operands are datetime objects before the comparison. Use the datetime.strptime(date_string, format_code) method to convert the string representation into a proper datetime object, making sure the format_code precisely matches the structure of the date_string. Avoid comparing string representations of dates unless you are certain the format guarantees correct lexicographical ordering that matches chronological order (like ISO 8601 format).