DateFormatter strftime

Date formatters' (:class:`~matplotlib.dates.DateFormatter`)

:meth:`~matplotlib.dates.DateFormatter.strftime` method will format

a :class:`datetime.datetime` object with the format string passed to

the formatter's constructor. This method accepts datetimes with years

before 1900, unlike :meth:`datetime.datetime.strftime`.

def _replace_common_substr(self, s1, s2, sub1, sub2, replacement):

"""Helper function for replacing substrings sub1 and sub2

# Find common indexes of substrings sub1 in s1 and sub2 in s2

# and make substitutions inplace. Because this is inplace,

# it is okay if len(replacement) != len(sub1), len(sub2).

while True:

j = s1.find(sub1, i)

if s2[j:j + len(sub2)] != sub2:

continue

s1 = s1[:j] + replacement + s1[j + len(sub1):]

s2 = s2[:j] + replacement + s2[j + len(sub2):]

return s1, s2

def strftime_pre_1900(self, dt, fmt=None):

"""Call time.strftime for years before 1900 by rolling

if fmt is None:

fmt = self.fmt

# Since python's time module's strftime implementation does not

# support %f microsecond (but the datetime module does), use a

# regular expression substitution to replace instances of %f.

# Note that this can be useful since python's floating-point

# precision representation for datetime causes precision to be

# more accurate closer to year 0 (around the year 2000, precision

# can be at 10s of microseconds).

fmt = re.sub(r'((^|[^%])(%%)*)%f',

r'\g<1>{0:06d}'.format(dt.microsecond), fmt)

# Move to between the years 1973 and 2000

year1 = year + ((2000 - year) // 28) * 28

year2 = year1 + 28

# Generate timestamp string for year and year+28

s1 = time.strftime(fmt, (year1,) + timetuple[1:])

s2 = time.strftime(fmt, (year2,) + timetuple[1:])

# Replace instances of respective years (both 2-digit and 4-digit)

# that are located at the same indexes of s1, s2 with dt's year.

# Note that C++'s strftime implementation does not use padded

# zeros or padded whitespace for %y or %Y for years before 100, but

# uses padded zeros for %x. (For example, try the runnable examples

# with .tm_year in the interval [-1900, -1800] on

# http://en.cppreference.com/w/c/chrono/strftime.) For ease of

# implementation, we always use padded zeros for %y, %Y, and %x.

s1, s2 = self._replace_common_substr(s1, s2,

"{0:04d}".format(year1),

"{0:04d}".format(year2),

"{0:04d}".format(dt.year))

s1, s2 = self._replace_common_substr(s1, s2,

"{0:02d}".format(year1 % 100),

"{0:02d}".format(year2 % 100),

"{0:02d}".format(dt.year % 100))

return cbook.unicode_safe(s1)

def strftime(self, dt, fmt=None):

"""Refer to documentation for datetime.strftime.

if fmt is None:

fmt = self.fmt

fmt = self.illegal_s.sub(r"\1", fmt)

fmt = fmt.replace("%s", "s")

if dt.year >= 1900:

# Note: in python 3.3 this is okay for years >= 1000,

# refer to http://bugs.python.org/issue177742

return cbook.unicode_safe(dt.strftime(fmt))

return self.strftime_pre_1900(dt, fmt)

def test_date_formatter_strftime():

"""

def test_strftime_fields(dt):

"""For datetime object dt, check DateFormatter fields"""

# Note: the last couple of %%s are to check multiple %s are handled

# properly; %% should get replaced by %.

formatter = mdates.DateFormatter("%w %d %m %y %Y %H %I %M %S %%%f %%x")

# Compute date fields without using datetime.strftime,

# since datetime.strftime does not work before year 1900

formatted_date_str = (

"{weekday} {day:02d} {month:02d} {year:02d} {full_year:04d} "

"{hour24:02d} {hour12:02d} {minute:02d} {second:02d} "

"%{microsecond:06d} %x"

.format(

# weeknum=dt.isocalendar()[1], # %U/%W {weeknum:02d}

# %w Sunday=0, weekday() Monday=0

weekday=str((dt.weekday() + 1) % 7),

day=dt.day,

month=dt.month,

year=dt.year % 100,

full_year=dt.year,

hour24=dt.hour,

hour12=((dt.hour-1) % 12) + 1,

minute=dt.minute,

second=dt.second,

microsecond=dt.microsecond))

assert_equal(formatter.strftime(dt), formatted_date_str)

try:

# Test strftime("%x") with the current locale.

import locale # Might not exist on some platforms, such as Windows

locale_formatter = mdates.DateFormatter("%x")

locale_d_fmt = locale.nl_langinfo(locale.D_FMT)

expanded_formatter = mdates.DateFormatter(locale_d_fmt)

assert_equal(locale_formatter.strftime(dt),

expanded_formatter.strftime(dt))

except ImportError:

pass

for year in range(1, 3000, 71):

# Iterate through random set of years

test_strftime_fields(datetime.datetime(year, 1, 1))

test_strftime_fields(datetime.datetime(year, 2, 3, 4, 5, 6, 12345))