API/BUG: make .at raise same exceptions as .loc

doc/source/whatsnew/v1.1.0.rst

@@ -63,7 +63,8 @@ Backwards incompatible API changes
 - :meth:`DataFrameGroupby.mean` and :meth:`SeriesGroupby.mean` (and similarly for :meth:`~DataFrameGroupby.median`, :meth:`~DataFrameGroupby.std`` and :meth:`~DataFrameGroupby.var``)
   now raise a  ``TypeError`` if a not-accepted keyword argument is passed into it.
   Previously a ``UnsupportedFunctionCall`` was raised (``AssertionError`` if ``min_count`` passed into :meth:`~DataFrameGroupby.median``) (:issue:`31485`)
-
+- :meth:`DataFrame.at` and :meth:`Series.at` will raise a ``TypeError`` instead of a ``ValueError`` if an incompatible key is passed, and ``KeyError`` if a missing key is passed, matching the behavior of ``.loc[]`` (:issue:`31722`)
+-
 
 .. ---------------------------------------------------------------------------
 

pandas/core/indexing.py

@@ -2100,21 +2100,11 @@ def _convert_key(self, key, is_setter: bool = False):
         if is_setter:
             return list(key)
 
-        for ax, i in zip(self.obj.axes, key):
-            if ax.is_integer():
-                if not is_integer(i):
-                    raise ValueError(
-                        "At based indexing on an integer index "
-                        "can only have integer indexers"
-                    )
-            else:
-                if is_integer(i) and not (ax.holds_integer() or ax.is_floating()):
-                    raise ValueError(
-                        "At based indexing on an non-integer "
-                        "index can only have non-integer "
-                        "indexers"
-                    )
-        return key
+        lkey = list(key)
+        for n, (ax, i) in enumerate(zip(self.obj.axes, key)):
+            lkey[n] = ax._convert_scalar_indexer(i, kind="loc")
+
+        return tuple(lkey)
 
 
 @Appender(IndexingMixin.iat.__doc__)

pandas/tests/indexing/test_scalar.py

@@ -129,38 +129,79 @@ def test_imethods_with_dups(self):
         result = df.iat[2, 0]
         assert result == 2
 
-    def test_at_to_fail(self):
+    def test_series_at_raises_type_error(self):
         # at should not fallback
         # GH 7814
-        s = Series([1, 2, 3], index=list("abc"))
-        result = s.at["a"]
+        # GH#31724 .at should match .loc
+        ser = Series([1, 2, 3], index=list("abc"))
+        result = ser.at["a"]
         assert result == 1
+        result = ser.loc["a"]
+        assert result == 1
+
         msg = (
-            "At based indexing on an non-integer index can only have "
-            "non-integer indexers"
+            "cannot do label indexing on <class 'pandas.core.indexes.base.Index'> "
+            r"with these indexers \[0\] of <class 'int'>"
         )
-        with pytest.raises(ValueError, match=msg):
-            s.at[0]
+        with pytest.raises(TypeError, match=msg):
+            ser.at[0]
+        with pytest.raises(TypeError, match=msg):
+            ser.loc[0]
 
+    def test_frame_raises_type_error(self):
+        # GH#31724 .at should match .loc
         df = DataFrame({"A": [1, 2, 3]}, index=list("abc"))
         result = df.at["a", "A"]
         assert result == 1
-        with pytest.raises(ValueError, match=msg):
+        result = df.loc["a", "A"]
+        assert result == 1
+
+        msg = (
+            "cannot do label indexing on <class 'pandas.core.indexes.base.Index'> "
+            r"with these indexers \[0\] of <class 'int'>"
+        )
+        with pytest.raises(TypeError, match=msg):
             df.at["a", 0]
+        with pytest.raises(TypeError, match=msg):
+            df.loc["a", 0]
+
+    def test_series_at_raises_key_error(self):
+        # GH#31724 .at should match .loc
 
-        s = Series([1, 2, 3], index=[3, 2, 1])
-        result = s.at[1]
+        ser = Series([1, 2, 3], index=[3, 2, 1])
+        result = ser.at[1]
         assert result == 3
-        msg = "At based indexing on an integer index can only have integer indexers"
-        with pytest.raises(ValueError, match=msg):
-            s.at["a"]
+        result = ser.loc[1]
+        assert result == 3
+
+        with pytest.raises(KeyError, match="a"):
+            ser.at["a"]
+        with pytest.raises(KeyError, match="a"):
+            # .at should match .loc
+            ser.loc["a"]
+
+    def test_frame_at_raises_key_error(self):
+        # GH#31724 .at should match .loc
 
         df = DataFrame({0: [1, 2, 3]}, index=[3, 2, 1])
+
         result = df.at[1, 0]
         assert result == 3
-        with pytest.raises(ValueError, match=msg):
+        result = df.loc[1, 0]
+        assert result == 3
+
+        with pytest.raises(KeyError, match="a"):
             df.at["a", 0]
+        with pytest.raises(KeyError, match="a"):
+            df.loc["a", 0]
+
+        with pytest.raises(KeyError, match="a"):
+            df.at[1, "a"]
+        with pytest.raises(KeyError, match="a"):
+            df.loc[1, "a"]
 
+    # TODO: belongs somewhere else?
+    def test_getitem_list_missing_key(self):
         # GH 13822, incorrect error string with non-unique columns when missing
         # column is accessed
         df = DataFrame({"x": [1.0], "y": [2.0], "z": [3.0]})