Python strptime()

Spread the love

While strftime() helps in converting a datetime object to a string representation, its counterpart, strptime(), does the exact opposite: it parses a string containing date and time into a Python datetime object. This conversion is invaluable when working with raw data from different sources or formats. In this article, we will delve deep into the functionality of strptime() and understand its various applications.

1. Basic Understanding

Before diving into the specifics, it’s essential to grasp the basic structure of strptime(). The function has the following signature:

datetime.strptime(date_string, format)
  • date_string: The string containing the date-time information.
  • format: The expected format of date_string, comprising various format codes (similar to those used in strftime()).

2. Format Codes for strptime( )

The format codes play a crucial role in the functionality of strptime(), dictating how different components of a date-time string should be interpreted. Below is a detailed breakdown of all the format codes that strptime() recognizes:

Date Components:

  • %a: Abbreviated weekday name. Examples: “Sun”, “Mon”, …
  • %A: Full weekday name. Examples: “Sunday”, “Monday”, …
  • %w: Weekday as a decimal number. Sunday is 0 and Monday is 1.
  • %d: Day of the month as a zero-padded decimal number. Examples range from “01” to “31”.
  • %b: Abbreviated month name. Examples: “Jan”, “Feb”, …
  • %B: Full month name. Examples: “January”, “February”, …
  • %m: Month as a zero-padded decimal number. Examples range from “01” for January to “12” for December.
  • %y: Last two digits of the year. Examples: “99” for 1999, “03” for 2003.
  • %Y: Full year. Examples: “1999”, “2003”.

Time Components:

  • %H: Hour (24-hour clock) as a zero-padded decimal number. Examples range from “00” to “23”.
  • %I: Hour (12-hour clock) as a zero-padded decimal number. Examples range from “01” to “12”.
  • %p: Either “AM” or “PM” based on the given time value. Note: Some locales use lowercase.
  • %M: Minute as a zero-padded decimal number. Examples range from “00” to “59”.
  • %S: Second as a zero-padded decimal number. Examples range from “00” to “59”.
  • %f: Microsecond, zero-padded on the left. Examples range from “000000” to “999999”.

Timezone Components:

  • %z: UTC offset in the form of +HHMM or -HHMM.
  • %Z: Time zone name. Examples: “UTC”, “EST”.

Locale’s Date and Time Components (these vary based on locale):

  • %c: Locale’s appropriate date and time representation.
  • %x: Locale’s appropriate date representation.
  • %X: Locale’s appropriate time representation.


  • %j: Day of the year as a zero-padded decimal number. Examples range from “001” to “366”.
  • %U: Week number of the year (with Sunday as the first day of the week) as a zero-padded decimal number. Examples range from “00” to “53”.
  • %W: Week number of the year (with Monday as the first day of the week) as a zero-padded decimal number.
  • %%: A literal ‘%’ character.

Understanding these format codes is crucial when working with strptime(), as they dictate how the function will interpret the date-time string. By ensuring that the format string passed to strptime() matches the structure of the date-time string, developers can achieve precise and reliable parsing across a wide range of date-time formats.

3. Practical Examples of strptime( )

Basic Date Parsing:

Suppose you’re given a simple string representing a date in the format of “YYYY-MM-DD” and you need to convert it to a Python datetime object.

from datetime import datetime

date_string = "2023-04-15"
date_object = datetime.strptime(date_string, '%Y-%m-%d')
print(date_object)  # Output: 2023-04-15 00:00:00

This example highlights the straightforward parsing of a date-only string.

Time Inclusion:

Now, consider you have a string that includes both date and time information.

time_string = "2023-04-15 14:25:36"
time_object = datetime.strptime(time_string, '%Y-%m-%d %H:%M:%S')
print(time_object)  # Output: 2023-04-15 14:25:36

Here, by specifying additional format codes (%H, %M, %S), strptime() can handle both date and precise time details.

Locale-specific Date Parsing:

Different regions might have their own conventions for representing date-time. Here’s how strptime() can handle a string that follows a locale-specific format.

locale_string = "Apr 15 2023  2:25PM"
locale_object = datetime.strptime(locale_string, '%b %d %Y %I:%M%p')
print(locale_object)  # Output: 2023-04-15 14:25:00

With the use of %b, %d, %Y, %I, %M, and %p, we can parse abbreviated month names, day of the month, year, hours in 12-hour format, minutes, and AM/PM designations respectively.

Parsing UTC Offset:

For applications requiring timezone-aware parsing, the %z format code can be helpful.

utc_string = "2023-04-15 14:25:36 +0500"
utc_object = datetime.strptime(utc_string, '%Y-%m-%d %H:%M:%S %z')
print(utc_object)  # Output: 2023-04-15 14:25:36+05:00

This example parses a string that includes UTC offset information, resulting in a timezone-aware datetime object.

Flexible Day and Month Parsing:

Sometimes, date strings aren’t zero-padded. strptime() can still manage this.

day_string = "2023-4-5"
day_object = datetime.strptime(day_string, '%Y-%m-%d')
print(day_object)  # Output: 2023-04-05 00:00:00

In this instance, the day and month aren’t zero-padded, but our format still works because strptime() can adapt to such variations.

These examples provide a glimpse into the vast potential of strptime(). From basic date-only strings to more intricate locale-specific formats and timezone considerations, strptime() offers an effective solution for transforming a myriad of string representations into functional datetime objects.

4. Common Pitfalls and Best Practices

  • Mismatched Format: The most common issue users encounter with strptime() is a mismatch between the format string and the date_string. If the format codes do not match the structure of the date_string, a ValueError will be raised.
  • Locale Consideration: If your application caters to international audiences, it’s crucial to be aware of locale-specific date and time formats. In such cases, libraries like dateutil.parser can provide more flexible parsing.
  • Ambiguous Dates: For strings like “01/02/2023”, it’s unclear whether the format is '%d/%m/%Y' or '%m/%d/%Y'. It’s crucial to know the expected format to avoid misinterpretations.

5. Conclusion

strptime() is a powerful tool in the Python developer’s arsenal, allowing for the seamless conversion of date and time strings into usable datetime objects. Whether you’re working with structured data in a known format or wrangling raw strings from various sources, understanding the nuances of strptime() can make your date-time handling tasks significantly more straightforward.

Leave a Reply