Python Date Comparison: A Comprehensive Tutorial

By Community / Developer
Jun 14, 2023

This post was written by Juan Reyes. Scroll down to view the author’s bio.

Python is a versatile programming language used widely for various tasks, including manipulating and comparing dates. This comprehensive tutorial will guide you through different techniques for comparing dates in Python. We will cover topics such as:

• comparing dates to today

• comparing two dates without time

• comparing DateTime strings

• comparing DateTime differences

• comparing timestamps

• converting date strings to Python date objects.

Compare date to today

Comparing a given date to today’s date is essential in many applications. To do this, you can use the DateTime module in Python. This module provides the DateTime class, which represents a single point in time.

The date class is a subclass of the DateTime class and only deals with dates, not times.

Here’s how you can compare a date to today:

from datetime import date

# Create a sample date
sample_date = date(2023, 3, 20)

# Get today's date
today = date.today()

# Compare dates
if sample_date < today:
    print("The sample date is in the past.")
elif sample_date > today:
    print("The sample date is in the future.")
else:
    print("The sample date is today.")

Let’s break down what we have done.

Import the date class

We start by importing the date class from the DateTime module. The date class allows us to work with dates (year, month, and day) without considering the time information (hour, minute, and second).

from datetime import date

Create a sample date

We create a sample date object called sample_date by instantiating the date class and passing the year, month, and day as arguments.

sample_date = date(2023, 3, 20)

Get today’s date

We use the today() method of the date class to get the current date. The method returns a date object representing the current date (year, month, and day) according to the system’s local time.

today = date.today()

Compare dates

We compare the sample_date with today using standard comparison operators (<, >, ==). Then, based on the comparison, we print whether the sample_date is in the past, future, or current date.

if sample_date < today: 
    print("The sample date is in the past.") 
elif sample_date > today: 
    print("The sample date is in the future.") 
else:
    print("The sample date is today.")

Here we’ve shown you how to compare a given date with today’s date in Python using the date class. By understanding how to compare dates, you can handle various scenarios where you need to determine the relationship between a date and the current date in your Python applications.

Compare two dates without time

You can use the date class to compare two dates without considering time. The following example demonstrates this:

from datetime import datetime
# Create two datetime objects with time
datetime1 = datetime(2023, 3, 20, 12, 0, 0)
datetime2 = datetime(2023, 3, 21, 18, 30, 0)
# Extract dates from datetime objects
date1 = datetime1.date()
date2 = datetime2.date()
# Compare dates
if date1 < date2:
    print("Date1 is earlier than Date2.")
elif date1 > date2:
    print("Date1 is later than Date2.")
else:
    print("Date1 and Date2 are the same.")

In this section, the code extracts the date portion from the DateTime objects and compares them using the standard comparison operators. Using the DateTime class, we’ve demonstrated how to compare two dates without considering their time information in Python. This approach is helpful when comparing DateTime objects based solely on the date portion, disregarding the time component.

Compare DateTime strings

Sometimes, you may need to compare datetime strings instead of DateTime or date objects. To do this, you can use the strptime function from the DateTime class to convert the strings into DateTime objects.

Here’s an example:

from datetime import datetime

# Two datetime strings
datetime_str1 = "2023-03-20 12:00:00"
datetime_str2 = "2023-03-21 18:30:00"

# Define the format of the datetime strings
datetime_format = "%Y-%m-%d %H:%M:%S"

# Convert the strings to datetime objects
datetime1 = datetime.strptime(datetime_str1, datetime_format)
datetime2 = datetime.strptime(datetime_str2, datetime_format)

# Compare datetime objects
if datetime1 < datetime2:
    print("Datetime1 is earlier than Datetime2.")
elif datetime1 > datetime2:
    print("Datetime1 is later than Datetime2.")
else:
    print("Datetime1 and Datetime2 are the same.")

The strptime function requires a format string that describes the structure of the input DateTime strings. In this example, the format string is “%Y-%m-%d %H:%M:%S, “ corresponding to the YYYY-MM-DD HH:MM:SS pattern. Then we define a format string datetime_format that corresponds to the structure of our datetime strings. In this case, the format is “%Y-%m-%d %H:%M:%S”. Finally, we use the strptime function from the DateTime class to convert the DateTime strings into datetime objects. The strptime function takes two arguments: the datetime and format strings. The resulting DateTime objects are stored in datetime1 and datetime2.

Now that we’ve shown you how to compare DateTime strings in Python by converting them into DateTime objects using the DateTime.strptime() function, you will be able to work with DateTime data in text format and perform comparisons as needed.

Compare DateTime difference

Comparing the difference between two DateTime objects is useful when calculating the duration between two dates or times. The DateTime module provides the TimeDelta class for representing durations.

Here’s how to compare DateTime differences:

from datetime import datetime, timedelta

# Create two datetime objects
datetime1 = datetime(2023, 3, 20, 12, 0, 0)
datetime2 = datetime(2023, 3, 21, 18, 30, 0)

# Calculate the difference between the two datetimes
difference = datetime2 - datetime1

# Create a timedelta object representing 24 hours
one_day = timedelta(days=1)

# Compare the difference to one day
if difference < one_day:
    print("The difference is less than one day.")
elif difference > one_day:
    print("The difference is more than one day.")
else:
    print("The difference is exactly one day.")

In this example, we’ve demonstrated calculating and comparing the time difference between two DateTime objects using Python’s datetime and TimeDelta classes. This approach allows you to determine the duration between two points in time and compare the lengths of different time intervals.

Let’s dissect the differences.

First, we start by importing the DateTime and TimeDelta classes from the DateTime module. The DateTime class allows us to combine date and time information, while the TimeDelta class represents the duration between two dates or times. Then we create the two DateTime objects to compare and subtract datetime1 from datetime2 to calculate their time difference. The result is a TimeDelta object, which we store in the time_difference variable. Next, we create a TimeDelta object representing a predefined duration, in this case, one day. We will use this duration to compare against the calculated time difference.

Finally, we compare the time_difference to the one_day duration using standard comparison operators (<, >, ==). Based on the comparison, we print whether the time difference is less than, more than, or precisely one day.

Compare timestamps

Timestamps are another way to represent points in time as single numbers. For example, you can convert a DateTime object to a timestamp using the timestamp method in Python.

To compare timestamps, you can follow these steps:

from datetime import datetime

# Create two datetime objects
datetime1 = datetime(2023, 3, 20, 12, 0, 0)
datetime2 = datetime(2023, 3, 21, 18, 30, 0)

# Convert datetime objects to timestamps
timestamp1 = datetime1.timestamp()
timestamp2 = datetime2.timestamp()

# Compare timestamps
if timestamp1 < timestamp2:
    print("Timestamp1 is earlier than Timestamp2.")
elif timestamp1 > timestamp2:
    print("Timestamp1 is later than Timestamp2.")
else:
    print("Timestamp1 and Timestamp2 are the same.")

This code converts the datetime objects to timestamps and compares them using standard comparison operators.

Python date from string

When working with dates in text format, you may need to convert them to Python date or datetime objects for further processing. You can use the strptime function for this purpose.

Here’s an example of converting a date string to a Python date object:

from datetime import datetime

# A date string
date_str = "2023-03-20"

# Define the format of the date string
date_format = "%Y-%m-%d"

# Convert the string to a date object
date_obj = datetime.strptime(date_str, date_format).date()

# Print the date object
print("Date object:", date_obj)

In this example, the format string “%Y-%m-%d” corresponds to the pattern YYYY-MM-DD. So, first, the strptime function is used to convert the date string to a DateTime object. The strptime function takes two arguments: the date and format strings. Then, we call the date() method on the DateTime object to extract the date part and store it in the date_obj variable. Finally, the date() method extracts the date part.

This approach is practical when working with date data in text format, such as data obtained from external sources or user input.

Conclusion

In this tutorial, we covered various techniques for comparing dates in Python, including comparing dates to today, comparing two dates without time, comparing datetime strings, comparing DateTime differences, comparing timestamps, and converting date strings to Python date objects. Understanding these techniques allows you to manipulate and compare dates in your Python projects effectively.

To learn about InfluxData’s Python support, click here.

About the author

This post was written by Juan Reyes. Juan is an engineer by profession and a dreamer by heart who crossed the seas to reach Japan following the promise of opportunity and challenge. While trying to find himself and build a meaningful life in the east, Juan borrows wisdom from his experiences as an entrepreneur, artist, hustler, father figure, husband, and friend to start writing about passion, meaning, self-development, leadership, relationships, and mental health. His many years of struggle and self-discovery have inspired him and drive to embark on a journey for wisdom.