CLN: GH29547 Replace old string formatting with f-strings

asv_bench/benchmarks/timeseries.py

@@ -394,33 +394,42 @@ def time_dup_string_tzoffset_dates(self, cache):
 
 class DatetimeAccessor:
 
-    params = [None, "US/Eastern", "UTC", dateutil.tz.tzutc()]
-    param_names = "tz"
-
-    def setup(self, tz):
+    params = (
+        [None, "US/Eastern", "UTC", dateutil.tz.tzutc()],
+        ["%Y-%m-%d %H:%M:%S.%f%z", "%Y-%m-%d %H:%M:%S%z"],
+        ["T", "S", "NS"],
+    )
+    param_names = ["tz", "fmt", "frequency"]
+
+    def setup(self, tz, fmt, frequency):
         N = 100000
-        self.series = Series(date_range(start="1/1/2000", periods=N, freq="T", tz=tz))
+        self.series = Series(
+            date_range(start="1/1/2000", periods=N, freq=frequency, tz=tz)
+        )
 
-    def time_dt_accessor(self, tz):
+    def time_dt_accessor(self, *args):
         self.series.dt
 
-    def time_dt_accessor_normalize(self, tz):
+    def time_dt_accessor_normalize(self, *args):
         self.series.dt.normalize()
 
-    def time_dt_accessor_month_name(self, tz):
+    def time_dt_accessor_month_name(self, *args):
         self.series.dt.month_name()
 
-    def time_dt_accessor_day_name(self, tz):
+    def time_dt_accessor_day_name(self, *args):
         self.series.dt.day_name()
 
-    def time_dt_accessor_time(self, tz):
+    def time_dt_accessor_time(self, *args):
         self.series.dt.time
 
-    def time_dt_accessor_date(self, tz):
+    def time_dt_accessor_date(self, *args):
         self.series.dt.date
 
-    def time_dt_accessor_year(self, tz):
+    def time_dt_accessor_year(self, *args):
         self.series.dt.year
 
+    def time_dt_accessor_strftime(self, _, fmt, *args):
+        self.series.dt.strftime(fmt)
+
 
 from .pandas_vb_common import setup  # noqa: F401 isort:skip

asv_bench/benchmarks/tslibs/timestamp.py

@@ -109,6 +109,17 @@ def time_month_name(self, tz, freq):
         self.ts.month_name()
 
 
+class TimestampMethods:
+    params = ["%Y-%m-%d %H:%M:%S", "%Y-%m-%d %H:%M:%S.%f"]
+    param_names = ["fmt"]
+
+    def setup(self, fmt):
+        self.ts = Timestamp("2020-05-23 18:06:13.123456789")
+
+    def time_strftime(self, fmt):
+        self.ts.strftime(fmt)
+
+
 class TimestampOps:
     params = [None, "US/Eastern", pytz.UTC, dateutil.tz.tzutc()]
     param_names = ["tz"]

doc/source/whatsnew/v1.1.0.rst

@@ -660,6 +660,7 @@ Datetimelike
 - Bug in :meth:`DatetimeIndex.intersection` and :meth:`TimedeltaIndex.intersection` with results not having the correct ``name`` attribute (:issue:`33904`)
 - Bug in :meth:`DatetimeArray.__setitem__`, :meth:`TimedeltaArray.__setitem__`, :meth:`PeriodArray.__setitem__` incorrectly allowing values with ``int64`` dtype to be silently cast (:issue:`33717`)
 - Bug in subtracting :class:`TimedeltaIndex` from :class:`Period` incorrectly raising ``TypeError`` in some cases where it should succeed and ``IncompatibleFrequency`` in some cases where it should raise ``TypeError`` (:issue:`33883`)
+- Bug in :meth:`Timestamp.strftime` did not display full nanosecond precision (:issue:`29461`)
 
 Timedelta
 ^^^^^^^^^

pandas/_libs/tslibs/timestamps.pyx

@@ -7,6 +7,7 @@ construction requirements, we need to do object instantiation in python
 shadows the python class, where we do any heavy lifting.
 """
 import warnings
+import time as _time
 
 import numpy as np
 cimport numpy as cnp
@@ -1469,6 +1470,22 @@ default 'raise'
             np.array([self.value], dtype='i8'), tz=self.tz)[0]
         return Timestamp(normalized_value).tz_localize(self.tz)
 
+    def strftime(self, format: str) -> str:
+        newformat = format
+        # only do additional processing if necessary
+        if self.nanosecond and '%f' in format:
+            newformat = []
+            for ch in format:
+                if ch == 'f':
+                    # remove accompanying %
+                    newformat.pop()
+                    # and put fractional seconds in its place
+                    newformat.append(f"{self.microsecond * 1000 + self.nanosecond}")
+                else:
+                    newformat.append(ch)
+            newformat = "".join(newformat)
+        return _time.strftime(newformat, self.timetuple())
+
 
 # Add the min and max fields at the class level
 cdef int64_t _NS_UPPER_BOUND = np.iinfo(np.int64).max

pandas/tests/scalar/timestamp/test_timestamp.py

@@ -15,7 +15,7 @@
 from pandas.compat.numpy import np_datetime64_compat
 import pandas.util._test_decorators as td
 
-from pandas import NaT, Timedelta, Timestamp
+from pandas import NaT, Timedelta, Timestamp, to_datetime
 import pandas._testing as tm
 
 from pandas.tseries import offsets
@@ -381,6 +381,19 @@ def test_tz_conversion_freq(self, tz_naive_fixture):
         t2 = Timestamp("2019-01-02 12:00", tz="UTC", freq="T")
         assert t2.tz_convert(tz="UTC").freq == t2.freq
 
+    @pytest.mark.parametrize(
+        "_input,fmt,_output",
+        [
+            ("2020-05-22 11:07:30", "%Y-%m-%d", "2020-05-22"),
+            ("2020-05-22 11:07:30.123456", "%Y-%m-%d %f", "2020-05-22 123456"),
+            ("2020-05-22 11:07:30.123456789", "%f", "123456789"),
+        ],
+    )
+    def test_strftime(self, _input, fmt, _output):
+        ts = Timestamp(_input)
+        result = ts.strftime(fmt)
+        assert result == _output
+
 
 class TestTimestampNsOperations:
     def test_nanosecond_string_parsing(self):
@@ -442,6 +455,20 @@ def test_nanosecond_timestamp(self):
         assert t.value == expected
         assert t.nanosecond == 10
 
+    @pytest.mark.parametrize(
+        "date",
+        [
+            "2020-05-22 08:53:19.123456789",
+            "2020-05-22 08:53:19.123456",
+            "2020-05-22 08:53:19",
+        ],
+    )
+    @pytest.mark.parametrize("fmt", ["%m/%d/%Y %H:%M:%S.%f", "%m%d%Y%H%M%S%f"])
+    def test_nanosecond_roundtrip(self, date, fmt):
+        ts = Timestamp(date)
+        string = ts.strftime(fmt)
+        assert ts == to_datetime(string, format=fmt)
+
 
 class TestTimestampToJulianDate:
     def test_compare_1700(self):

pandas/util/_validators.py

@@ -295,13 +295,13 @@ def validate_axis_style_args(data, args, kwargs, arg_name, method_name):
             raise TypeError(msg)
 
         msg = (
-            "Interpreting call\n\t'.{method_name}(a, b)' as "
-            "\n\t'.{method_name}(index=a, columns=b)'.\nUse named "
-            "arguments to remove any ambiguity. In the future, using "
-            "positional arguments for 'index' or 'columns' will raise "
-            "a 'TypeError'."
+            f"Interpreting call\n\t'.{method_name}(a, b)' as "
+            + f"\n\t'.{method_name}(index=a, columns=b)'.\nUse named "
+            + f"arguments to remove any ambiguity. In the future, using "
+            + f"positional arguments for 'index' or 'columns' will raise "
+            + f"a 'TypeError'."
         )
-        warnings.warn(msg.format(method_name=method_name), FutureWarning, stacklevel=4)
+        warnings.warn(msg, FutureWarning, stacklevel=4)
         out[data._get_axis_name(0)] = args[0]
         out[data._get_axis_name(1)] = args[1]
     else:
@@ -370,12 +370,15 @@ def validate_percentile(q: Union[float, Iterable[float]]) -> np.ndarray:
     ------
     ValueError if percentiles are not in given interval([0, 1]).
     """
-    msg = "percentiles should all be in the interval [0, 1]. Try {0} instead."
     q_arr = np.asarray(q)
+    msg = (
+        f"percentiles should all be in the interval [0, 1]. "
+        f"Try {q_arr / 100.0} instead."
+    )
     if q_arr.ndim == 0:
         if not 0 <= q_arr <= 1:
-            raise ValueError(msg.format(q_arr / 100.0))
+            raise ValueError(msg)
     else:
         if not all(0 <= qs <= 1 for qs in q_arr):
-            raise ValueError(msg.format(q_arr / 100.0))
+            raise ValueError(msg)
     return q_arr