[WIP] perf improvements for strftime

pandas/_libs/tslib.pyi

@@ -9,6 +9,7 @@ def format_array_from_datetime(
     tz: tzinfo | None = ...,
     format: str | None = ...,
     na_rep: object = ...,
+    fast_strftime: bool = ...,
 ) -> npt.NDArray[np.object_]: ...
 def array_with_unit_to_datetime(
     values: np.ndarray,

pandas/_libs/tslib.pyx

@@ -60,6 +60,10 @@ from pandas._libs.tslibs.nattype cimport (
 )
 from pandas._libs.tslibs.timestamps cimport _Timestamp
 
+from pandas._libs.tslibs.strftime import (
+    UnsupportedStrFmtDirective,
+    convert_strftime_format,
+)
 from pandas._libs.tslibs.timestamps import Timestamp
 
 # Note: this is the only non-tslibs intra-pandas dependency here
@@ -101,7 +105,8 @@ def format_array_from_datetime(
     ndarray[int64_t] values,
     tzinfo tz=None,
     str format=None,
-    object na_rep=None
+    object na_rep=None,
+    fast_strftime=True,
 ) -> np.ndarray:
     """
     return a np object array of the string formatted values
@@ -114,19 +119,23 @@ def format_array_from_datetime(
           a strftime capable string
     na_rep : optional, default is None
           a nat format
+    fast_strftime : bool, default True
+          If `True` (default) and the format permits it, a faster formatting
+          method will be used. See `convert_strftime_format`.
 
     Returns
     -------
     np.ndarray[object]
     """
     cdef:
-        int64_t val, ns, N = len(values)
+        int64_t val, ns, y, h, N = len(values)
         ndarray[int64_t] consider_values
         bint show_ms = False, show_us = False, show_ns = False
         bint basic_format = False
         ndarray[object] result = np.empty(N, dtype=object)
         object ts, res
         npy_datetimestruct dts
+        object str_format, loc_s
 
     if na_rep is None:
         na_rep = 'NaT'
@@ -146,6 +155,28 @@ def format_array_from_datetime(
                 consider_values //= 1000
                 show_ms = (consider_values % 1000).any()
 
+    elif format == "%Y-%m-%d %H:%M:%S":
+        # Same format as default, but with hardcoded precision (s)
+        basic_format = True
+        show_ns = show_us = show_ms = False
+
+    elif format == "%Y-%m-%d %H:%M:%S.%f":
+        # Same format as default, but with hardcoded precision (us)
+        basic_format = show_us = True
+        show_ns = show_ms = False
+
+    elif fast_strftime:
+        if format is None:
+            # We'll fallback to the Timestamp.str method
+            fast_strftime = False
+        else:
+            try:
+                # Try to get the string formatting template for this format
+                str_format, loc_s = convert_strftime_format(format)
+            except UnsupportedStrFmtDirective:
+                # Unsupported directive: fallback to standard `strftime`
+                fast_strftime = False
+
     for i in range(N):
         val = values[i]
 
@@ -167,10 +198,36 @@ def format_array_from_datetime(
 
             result[i] = res
 
+        elif fast_strftime:
+
+            if tz is None:
+                dt64_to_dtstruct(val, &dts)
+
+                # Use string formatting for faster strftime
+                y = dts.year
+                h = dts.hour
+                result[i] = str_format % {
+                    "year": y,
+                    "shortyear": y % 100,
+                    "month": dts.month,
+                    "day": dts.day,
+                    "hour": dts.hour,
+                    "hour12": 12 if h in (0, 12) else (h % 12),
+                    "ampm": loc_s.pm if (h // 12) else loc_s.am,
+                    "min": dts.min,
+                    "sec": dts.sec,
+                    "us": dts.us,
+                }
+            else:
+                ts = Timestamp(val, tz=tz)
+
+                # Use string formatting for faster strftime
+                result[i] = ts.fast_strftime(str_format, loc_s)
         else:
 
             ts = Timestamp(val, tz=tz)
             if format is None:
+                # Use datetime.str, that returns ts.isoformat(sep=' ')
                 result[i] = str(ts)
             else:
 
@@ -179,6 +236,7 @@ def format_array_from_datetime(
                 try:
                     result[i] = ts.strftime(format)
                 except ValueError:
+                    # Use datetime.str, that returns ts.isoformat(sep=' ')
                     result[i] = str(ts)
 
     return result

pandas/_libs/tslibs/__init__.py

@@ -9,6 +9,8 @@
     "OutOfBoundsTimedelta",
     "IncompatibleFrequency",
     "Period",
+    "convert_strftime_format",
+    "UnsupportedStrFmtDirective",
     "Resolution",
     "Timedelta",
     "normalize_i8_timestamps",
@@ -48,6 +50,10 @@
     IncompatibleFrequency,
     Period,
 )
+from pandas._libs.tslibs.strftime import (
+    UnsupportedStrFmtDirective,
+    convert_strftime_format,
+)
 from pandas._libs.tslibs.timedeltas import (
     Timedelta,
     delta_to_nanoseconds,

pandas/_libs/tslibs/offsets.pyx

@@ -1548,8 +1548,10 @@ cdef class BusinessHour(BusinessMixin):
 
     def _repr_attrs(self) -> str:
         out = super()._repr_attrs()
+        # Use python string formatting to be faster than strftime
+        #   f'{st.strftime("%H:%M")}-{en.strftime("%H:%M")}'
         hours = ",".join(
-            f'{st.strftime("%H:%M")}-{en.strftime("%H:%M")}'
+            f'{st.hour:02d}:{st.minute:02d}-{en.hour:02d}:{en.minute:02d}'
             for st, en in zip(self.start, self.end)
         )
         attrs = [f"{self._prefix}={hours}"]

pandas/_libs/tslibs/period.pyi

@@ -76,6 +76,7 @@ class Period:
     def _from_ordinal(cls, ordinal: int, freq) -> Period: ...
     @classmethod
     def now(cls, freq: BaseOffset = ...) -> Period: ...
+    def fast_strftime(self, fmt_str: str, loc_s: object) -> str: ...
     def strftime(self, fmt: str) -> str: ...
     def to_timestamp(
         self,