List indexer on PeriodIndex doesn't coerce strings (#11278)

Author: proost

doc/source/whatsnew/v1.0.0.rst

@@ -769,6 +769,7 @@ Interval
 Indexing
 ^^^^^^^^
 
+- List datetime string indexer could fail on :class:`PeriodIndex` or :class:`DatetimeIndex` (:issue:`11278`)
 - Bug in assignment using a reverse slicer (:issue:`26939`)
 - Bug in :meth:`DataFrame.explode` would duplicate frame in the presence of duplicates in the index (:issue:`28010`)
 - Bug in reindexing a :meth:`PeriodIndex` with another type of index that contained a `Period` (:issue:`28323`) (:issue:`28337`)

pandas/core/common.py

@@ -15,12 +15,17 @@
 
 from pandas._libs import lib, tslibs
 
-from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike
+from pandas.core.dtypes.cast import (
+    construct_1d_datetimelike_array_from_listlike,
+    construct_1d_object_array_from_listlike,
+)
 from pandas.core.dtypes.common import (
     is_array_like,
     is_bool_dtype,
+    is_datetime64_any_dtype,
     is_extension_array_dtype,
     is_integer,
+    is_period_dtype,
 )
 from pandas.core.dtypes.generic import ABCIndex, ABCIndexClass, ABCSeries
 from pandas.core.dtypes.inference import _iterable_not_string
@@ -224,6 +229,11 @@ def asarray_tuplesafe(values, dtype=None):
     if isinstance(values, list) and dtype in [np.object_, object]:
         return construct_1d_object_array_from_listlike(values)
 
+    if isinstance(values, list) and (
+        is_datetime64_any_dtype(dtype) or is_period_dtype(dtype)
+    ):
+        return construct_1d_datetimelike_array_from_listlike(values, dtype)
+
     result = np.asarray(values, dtype=dtype)
 
     if issubclass(result.dtype.type, str):

pandas/core/dtypes/cast.py

@@ -23,6 +23,7 @@
     is_bool_dtype,
     is_complex,
     is_complex_dtype,
+    is_datetime64_any_dtype,
     is_datetime64_dtype,
     is_datetime64_ns_dtype,
     is_datetime64tz_dtype,
@@ -34,6 +35,7 @@
     is_integer,
     is_integer_dtype,
     is_object_dtype,
+    is_period_dtype,
     is_scalar,
     is_string_dtype,
     is_timedelta64_dtype,
@@ -1505,3 +1507,37 @@ def maybe_cast_to_integer_array(arr, dtype, copy: bool = False):
 
     if is_integer_dtype(dtype) and (is_float_dtype(arr) or is_object_dtype(arr)):
         raise ValueError("Trying to coerce float values to integers")
+
+
+def construct_1d_datetimelike_array_from_listlike(values, dtype):
+    """
+    Transform any list-like object into a 1-dimensional pandas array of object dtype.
+
+    Parameters
+    ----------
+    values : any list-like object
+
+    Raises
+    ------
+    TypeError
+        If `values` is not list like or
+        dtype is not period type or datetime64 type
+
+    Returns
+    -------
+    1-dimensional pandas array of dtype object
+    """
+
+    if not is_list_like(values):
+        raise TypeError(f"{values} not list-like")
+
+    if is_period_dtype(dtype):
+        from pandas.core.arrays import PeriodArray
+
+        arr = PeriodArray._from_sequence(values, dtype=dtype)
+    elif is_datetime64_any_dtype(dtype):
+        arr = maybe_cast_to_datetime(values, dtype=dtype)
+    else:
+        raise TypeError(f"{values} not datetime-like list")
+
+    return arr

pandas/core/indexes/base.py

@@ -66,6 +66,8 @@
 from pandas.core.accessor import CachedAccessor
 import pandas.core.algorithms as algos
 from pandas.core.arrays import ExtensionArray
+from pandas.core.arrays.datetimes import DatetimeArray
+from pandas.core.arrays.period import PeriodArray
 from pandas.core.base import IndexOpsMixin, PandasObject
 import pandas.core.common as com
 from pandas.core.construction import extract_array
@@ -3058,7 +3060,12 @@ def _convert_listlike_indexer(self, keyarr, kind=None):
 
     @Appender(_index_shared_docs["_convert_arr_indexer"])
     def _convert_arr_indexer(self, keyarr):
-        keyarr = com.asarray_tuplesafe(keyarr)
+        if isinstance(keyarr, list) and (
+            is_datetime64_any_dtype(self.dtype) or is_period_dtype(self.dtype)
+        ):
+            keyarr = com.asarray_tuplesafe(keyarr, self.dtype)
+        else:
+            keyarr = com.asarray_tuplesafe(keyarr)
         return keyarr
 
     _index_shared_docs[
@@ -3122,6 +3129,14 @@ def _convert_list_indexer(self, keyarr, kind=None):
                 keyarr = np.where(keyarr < 0, len(self) + keyarr, keyarr)
                 return keyarr
 
+        elif isinstance(keyarr, PeriodArray) or isinstance(keyarr, DatetimeArray):
+            indexer = self.get_indexer_for(keyarr)
+            if (indexer >= 0).all():
+                return indexer
+
+            indexer[indexer < 0] = len(self)
+            return maybe_convert_indices(indexer, len(self))
+
         return None
 
     def _invalid_indexer(self, form, key):

pandas/tests/indexing/test_loc.py

@@ -6,7 +6,7 @@
 import pytest
 
 import pandas as pd
-from pandas import DataFrame, Series, Timestamp, date_range
+from pandas import DataFrame, Period, Series, Timestamp, date_range, period_range
 from pandas.api.types import is_scalar
 from pandas.tests.indexing.common import Base
 import pandas.util.testing as tm
@@ -939,6 +939,69 @@ def test_loc_reverse_assignment(self):
 
         tm.assert_series_equal(result, expected)
 
+    @pytest.mark.parametrize(
+        "idx,labels,expected_idx",
+        [
+            (
+                period_range(start="2000", periods=20, freq="D"),
+                ["2000-01-04", "2000-01-08", "2000-01-12"],
+                [
+                    Period("2000-01-04", freq="D"),
+                    Period("2000-01-08", freq="D"),
+                    Period("2000-01-12", freq="D"),
+                ],
+            ),
+            (
+                date_range(start="2000", periods=20, freq="D"),
+                ["2000-01-04", "2000-01-08", "2000-01-12"],
+                [
+                    Timestamp("2000-01-04", freq="D"),
+                    Timestamp("2000-01-08", freq="D"),
+                    Timestamp("2000-01-12", freq="D"),
+                ],
+            ),
+        ],
+    )
+    def test_loc_with_datetime_string_list(self, idx, labels, expected_idx):
+        # GH 11278
+        s = Series(range(20), index=idx)
+        df = DataFrame(range(20), index=idx)
+
+        expected_value = [3, 7, 11]
+        expected_s = Series(expected_value, expected_idx)
+        expected_df = DataFrame(expected_value, expected_idx)
+
+        tm.assert_series_equal(expected_s, s.loc[labels])
+        tm.assert_series_equal(expected_s, s[labels])
+        tm.assert_frame_equal(expected_df, df.loc[labels])
+
+    @pytest.mark.parametrize(
+        "idx,labels,msg",
+        [
+            (
+                period_range(start="2000", periods=20, freq="D"),
+                ["2000-01-04", "2000-01-30"],
+                "indices are out-of-bounds",
+            ),
+            (
+                date_range(start="2000", periods=20, freq="D"),
+                ["2000-01-04", "2000-01-30"],
+                "indices are out-of-bounds",
+            ),
+        ],
+    )
+    def test_loc_with_datetime_string_and_missing_value(self, idx, labels, msg):
+        # GH 11278
+        s = Series(range(20), index=idx)
+        df = DataFrame(range(20), index=idx)
+
+        with pytest.raises(IndexError, match=msg):
+            s.loc[labels]
+        with pytest.raises(IndexError, match=msg):
+            s[labels]
+        with pytest.raises(IndexError, match=msg):
+            df.loc[labels]
+
 
 def test_series_loc_getitem_label_list_missing_values():
     # gh-11428