BUG: Series.to_dict does not return native Python types

pandas/core/dtypes/cast.py

@@ -159,6 +159,20 @@ def maybe_box_datetimelike(value: Scalar, dtype: Optional[Dtype] = None) -> Scal
     return value
 
 
+# TODO: this should be a TypeVar
+def maybe_box_native(value: Union[Series, Scalar]) -> Union[ABCSeries, Scalar]:
+    if not is_scalar(value):
+        pass
+    elif is_datetime_or_timedelta_dtype(value):
+        value = maybe_box_datetimelike(value)
+    elif is_float_dtype(value):
+        value = float(value)
+    elif is_integer_dtype(value):
+        with suppress(ValueError):
+            value = int(value)
+    return value
+
+
 def maybe_downcast_to_dtype(result, dtype: Union[str, np.dtype]):
     """
     try to cast to the specified dtype (e.g. convert back to bool/int

pandas/core/frame.py

@@ -84,7 +84,7 @@
     find_common_type,
     infer_dtype_from_scalar,
     invalidate_string_dtypes,
-    maybe_box_datetimelike,
+    maybe_box_native,
     maybe_cast_to_datetime,
     maybe_casted_values,
     maybe_convert_platform,
@@ -1539,15 +1539,15 @@ def to_dict(self, orient="dict", into=dict):
                     (
                         "data",
                         [
-                            list(map(maybe_box_datetimelike, t))
+                            list(map(maybe_box_native, t))
                             for t in self.itertuples(index=False, name=None)
                         ],
                     ),
                 )
             )
 
         elif orient == "series":
-            return into_c((k, maybe_box_datetimelike(v)) for k, v in self.items())
+            return into_c((k, maybe_box_native(v)) for k, v in self.items())
 
         elif orient == "records":
             columns = self.columns.tolist()
@@ -1556,8 +1556,7 @@ def to_dict(self, orient="dict", into=dict):
                 for row in self.itertuples(index=False, name=None)
             )
             return [
-                into_c((k, maybe_box_datetimelike(v)) for k, v in row.items())
-                for row in rows
+                into_c((k, maybe_box_native(v)) for k, v in row.items()) for row in rows
             ]
 
         elif orient == "index":

pandas/core/series.py

@@ -42,6 +42,7 @@
 
 from pandas.core.dtypes.cast import (
     convert_dtypes,
+    maybe_box_native,
     maybe_cast_to_extension_array,
     validate_numeric_casting,
 )
@@ -1600,7 +1601,7 @@ def to_dict(self, into=dict):
         """
         # GH16122
         into_c = com.standardize_mapping(into)
-        return into_c(self.items())
+        return into_c((k, maybe_box_native(v)) for k, v in self.items())
 
     def to_frame(self, name=None) -> "DataFrame":
         """

pandas/tests/frame/methods/test_to_dict.py

@@ -256,31 +256,42 @@ def test_to_dict_wide(self):
         expected = {f"A_{i:d}": i for i in range(256)}
         assert result == expected
 
-    def test_to_dict_orient_dtype(self):
-        # GH22620 & GH21256
-
-        df = DataFrame(
-            {
-                "bool": [True, True, False],
-                "datetime": [
+    @pytest.mark.parametrize(
+        "data,dtype",
+        (
+            ([True, True, False], bool),
+            [
+                [
                     datetime(2018, 1, 1),
                     datetime(2019, 2, 2),
                     datetime(2020, 3, 3),
                 ],
-                "float": [1.0, 2.0, 3.0],
-                "int": [1, 2, 3],
-                "str": ["X", "Y", "Z"],
-            }
-        )
+                Timestamp,
+            ],
+            [[1.0, 2.0, 3.0], float],
+            [[1, 2, 3], int],
+            [["X", "Y", "Z"], str],
+        ),
+    )
+    def test_to_dict_orient_dtype(self, data, dtype):
+        # GH22620 & GH21256
 
-        expected = {
-            "int": int,
-            "float": float,
-            "str": str,
-            "datetime": Timestamp,
-            "bool": bool,
-        }
+        df = DataFrame({"a": data})
+        d = df.to_dict(orient="records")
+        assert all(type(record["a"]) is dtype for record in d)
+
+    @pytest.mark.parametrize(
+        "data,dtype",
+        (
+            [np.int64(9), int],
+            [np.float64(1.1), float],
+            [np.bool_(True), bool],
+            [np.datetime64("2005-02-25"), Timestamp],
+        ),
+    )
+    def test_to_dict_scalar_constructor_orient_dtype(self, data, dtype):
+        # GH22620 & GH21256
 
-        for df_dict in df.to_dict("records"):
-            result = {col: type(df_dict[col]) for col in list(df.columns)}
-            assert result == expected
+        df = DataFrame({"a": data}, index=[0])
+        d = df.to_dict(orient="records")
+        assert type(d[0]["a"]) is dtype

pandas/tests/series/methods/test_to_dict.py

@@ -1,5 +1,6 @@
 import collections
 
+import numpy as np
 import pytest
 
 from pandas import Series
@@ -20,3 +21,14 @@ def test_to_dict(self, mapping, datetime_series):
         from_method = Series(datetime_series.to_dict(collections.Counter))
         from_constructor = Series(collections.Counter(datetime_series.items()))
         tm.assert_series_equal(from_method, from_constructor)
+
+    @pytest.mark.parametrize(
+        "input",
+        ({"a": np.int64(64), "b": 10}, {"a": np.int64(64), "b": 10, "c": "ABC"}),
+    )
+    def test_to_dict_return_types(self, input):
+        # GH25969
+
+        d = Series(input).to_dict()
+        assert isinstance(d["a"], int)
+        assert isinstance(d["b"], int)