BUG: Behavior with fallback between raise and coerce #46071

doc/source/whatsnew/v1.5.0.rst

@@ -902,6 +902,7 @@ Datetimelike
 - Bug in :meth:`DatetimeIndex.resolution` incorrectly returning "day" instead of "nanosecond" for nanosecond-resolution indexes (:issue:`46903`)
 - Bug in :class:`Timestamp` with an integer or float value and ``unit="Y"`` or ``unit="M"`` giving slightly-wrong results (:issue:`47266`)
 - Bug in :class:`.DatetimeArray` construction when passed another :class:`.DatetimeArray` and ``freq=None`` incorrectly inferring the freq from the given array (:issue:`47296`)
+- Bug in :func:`to_datetime` where ``infer_datetime_format`` fallback would not run if ``errors=coerce`` (:issue:`46071`)
 - Bug in :func:`to_datetime` where ``OutOfBoundsDatetime`` would be thrown even if ``errors=coerce`` if there were more than 50 rows (:issue:`45319`)
 - Bug when adding a :class:`DateOffset` to a :class:`Series` would not add the ``nanoseconds`` field (:issue:`47856`)
 -

pandas/core/tools/datetimes.py

@@ -501,6 +501,9 @@ def _array_strptime_with_fallback(
         if "%Z" in fmt or "%z" in fmt:
             return _return_parsed_timezone_results(result, timezones, tz, name)
 
+        if infer_datetime_format and np.isnan(result).any():
+            return None
+
     return _box_as_indexlike(result, utc=utc, name=name)
 
 
@@ -798,7 +801,10 @@ def to_datetime(
         If :const:`True` and no `format` is given, attempt to infer the format
         of the datetime strings based on the first non-NaN element,
         and if it can be inferred, switch to a faster method of parsing them.
-        In some cases this can increase the parsing speed by ~5-10x.
+        In some cases this can increase the parsing speed by ~5-10x. If subsequent
+        datetime strings do not follow the inferred format, parsing will fall
+        back to the slower method of determining the format for each
+        string individually.
     origin : scalar, default 'unix'
         Define the reference date. The numeric values would be parsed as number
         of units (defined by `unit`) since this reference date.

pandas/tests/arrays/test_datetimes.py

@@ -3,11 +3,13 @@
 """
 import operator
 
+from dateutil.parser._parser import ParserError
 import numpy as np
 import pytest
 
 from pandas._libs.tslibs import tz_compare
 from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
+from pandas.errors import OutOfBoundsDatetime
 
 from pandas.core.dtypes.dtypes import DatetimeTZDtype
 
@@ -639,3 +641,40 @@ def test_tz_localize_t2d(self):
 
         roundtrip = expected.tz_localize("US/Pacific")
         tm.assert_datetime_array_equal(roundtrip, dta)
+
+    @pytest.mark.parametrize(
+        "error",
+        ["coerce", "raise"],
+    )
+    def test_coerce_fallback(self, error):
+        # GH#46071
+        s = pd.Series(["6/30/2025", "1 27 2024"])
+        expected = pd.Series(
+            [pd.Timestamp("2025-06-30 00:00:00"), pd.Timestamp("2024-01-27 00:00:00")]
+        )
+
+        result = pd.to_datetime(s, errors=error, infer_datetime_format=True)
+
+        if error == "coerce":
+            assert result[1] is not pd.NaT
+
+        tm.assert_series_equal(expected, result)
+
+        expected2 = pd.Series([pd.Timestamp("2000-01-01 00:00:00"), pd.NaT])
+
+        es1 = pd.Series(["1/1/2000", "7/12/1200"])
+        es2 = pd.Series(["1/1/2000", "Hello"])
+
+        if error == "coerce":
+            eres1 = pd.to_datetime(es1, errors=error, infer_datetime_format=True)
+            eres2 = pd.to_datetime(es2, errors=error, infer_datetime_format=True)
+            tm.assert_series_equal(expected2, eres1)
+            tm.assert_series_equal(expected2, eres2)
+        else:
+            with pytest.raises(
+                OutOfBoundsDatetime, match="Out of bounds nanosecond timestamp"
+            ):
+                pd.to_datetime(es1, errors=error, infer_datetime_format=True)
+
+            with pytest.raises(ParserError, match="Unknown string format: Hello"):
+                pd.to_datetime(es2, errors=error, infer_datetime_format=True)