change dict to literal (#38207)

Author: Qbiwan

pandas/tests/frame/indexing/test_indexing.py

@@ -714,7 +714,7 @@ def test_setitem_empty(self):
         tm.assert_frame_equal(result, df)
 
     @pytest.mark.parametrize("dtype", ["float", "int64"])
-    @pytest.mark.parametrize("kwargs", [dict(), dict(index=[1]), dict(columns=["A"])])
+    @pytest.mark.parametrize("kwargs", [{}, {"index": [1]}, {"columns": ["A"]}])
     def test_setitem_empty_frame_with_boolean(self, dtype, kwargs):
         # see gh-10126
         kwargs["dtype"] = dtype
@@ -1238,7 +1238,7 @@ def test_single_element_ix_dont_upcast(self, float_frame):
         assert is_integer(result)
 
         # GH 11617
-        df = DataFrame(dict(a=[1.23]))
+        df = DataFrame({"a": [1.23]})
         df["b"] = 666
 
         result = df.loc[0, "b"]

pandas/tests/frame/indexing/test_where.py

@@ -356,11 +356,11 @@ def test_where_datetime(self):
 
         # GH 3311
         df = DataFrame(
-            dict(
-                A=date_range("20130102", periods=5),
-                B=date_range("20130104", periods=5),
-                C=np.random.randn(5),
-            )
+            {
+                "A": date_range("20130102", periods=5),
+                "B": date_range("20130104", periods=5),
+                "C": np.random.randn(5),
+            }
         )
 
         stamp = datetime(2013, 1, 3)
@@ -618,7 +618,7 @@ def test_df_where_change_dtype(self):
 
         tm.assert_frame_equal(result, expected)
 
-    @pytest.mark.parametrize("kwargs", [dict(), dict(other=None)])
+    @pytest.mark.parametrize("kwargs", [{}, {"other": None}])
     def test_df_where_with_category(self, kwargs):
         # GH#16979
         df = DataFrame(np.arange(2 * 3).reshape(2, 3), columns=list("ABC"))

pandas/tests/frame/methods/test_fillna.py

@@ -53,10 +53,10 @@ def test_fillna_mixed_float(self, mixed_float_frame):
         mf = mixed_float_frame.reindex(columns=["A", "B", "D"])
         mf.loc[mf.index[-10:], "A"] = np.nan
         result = mf.fillna(value=0)
-        _check_mixed_float(result, dtype=dict(C=None))
+        _check_mixed_float(result, dtype={"C": None})
 
         result = mf.fillna(method="pad")
-        _check_mixed_float(result, dtype=dict(C=None))
+        _check_mixed_float(result, dtype={"C": None})
 
     def test_fillna_empty(self):
         # empty frame (GH#2778)
@@ -262,7 +262,7 @@ def test_fillna_dtype_conversion(self):
         tm.assert_frame_equal(result, expected)
 
         # equiv of replace
-        df = DataFrame(dict(A=[1, np.nan], B=[1.0, 2.0]))
+        df = DataFrame({"A": [1, np.nan], "B": [1.0, 2.0]})
         for v in ["", 1, np.nan, 1.0]:
             expected = df.replace(np.nan, v)
             result = df.fillna(v)

pandas/tests/frame/methods/test_sort_values.py

@@ -305,11 +305,11 @@ def test_sort_values_nat_values_in_int_column(self):
         float_values = (2.0, -1.797693e308)
 
         df = DataFrame(
-            dict(int=int_values, float=float_values), columns=["int", "float"]
+            {"int": int_values, "float": float_values}, columns=["int", "float"]
         )
 
         df_reversed = DataFrame(
-            dict(int=int_values[::-1], float=float_values[::-1]),
+            {"int": int_values[::-1], "float": float_values[::-1]},
             columns=["int", "float"],
             index=[1, 0],
         )
@@ -329,12 +329,12 @@ def test_sort_values_nat_values_in_int_column(self):
         # and now check if NaT is still considered as "na" for datetime64
         # columns:
         df = DataFrame(
-            dict(datetime=[Timestamp("2016-01-01"), NaT], float=float_values),
+            {"datetime": [Timestamp("2016-01-01"), NaT], "float": float_values},
             columns=["datetime", "float"],
         )
 
         df_reversed = DataFrame(
-            dict(datetime=[NaT, Timestamp("2016-01-01")], float=float_values[::-1]),
+            {"datetime": [NaT, Timestamp("2016-01-01")], "float": float_values[::-1]},
             columns=["datetime", "float"],
             index=[1, 0],
         )

pandas/tests/frame/methods/test_to_csv.py

@@ -38,7 +38,7 @@
 
 class TestDataFrameToCSV:
     def read_csv(self, path, **kwargs):
-        params = dict(index_col=0, parse_dates=True)
+        params = {"index_col": 0, "parse_dates": True}
         params.update(**kwargs)
 
         return pd.read_csv(path, **params)
@@ -248,7 +248,7 @@ def make_dtnat_arr(n, nnat=None):
 
         # s3=make_dtnjat_arr(chunksize+5,0)
         with tm.ensure_clean("1.csv") as pth:
-            df = DataFrame(dict(a=s1, b=s2))
+            df = DataFrame({"a": s1, "b": s2})
             df.to_csv(pth, chunksize=chunksize)
 
             recons = self.read_csv(pth).apply(to_datetime)
@@ -260,7 +260,7 @@ def _do_test(
             df, r_dtype=None, c_dtype=None, rnlvl=None, cnlvl=None, dupe_col=False
         ):
 
-            kwargs = dict(parse_dates=False)
+            kwargs = {"parse_dates": False}
             if cnlvl:
                 if rnlvl is not None:
                     kwargs["index_col"] = list(range(rnlvl))
@@ -291,7 +291,7 @@ def _to_uni(x):
                 recons.index = ix
                 recons = recons.iloc[:, rnlvl - 1 :]
 
-            type_map = dict(i="i", f="f", s="O", u="O", dt="O", p="O")
+            type_map = {"i": "i", "f": "f", "s": "O", "u": "O", "dt": "O", "p": "O"}
             if r_dtype:
                 if r_dtype == "u":  # unicode
                     r_dtype = "O"
@@ -738,7 +738,7 @@ def create_cols(name):
         df = pd.concat([df_float, df_int, df_bool, df_object, df_dt], axis=1)
 
         # dtype
-        dtypes = dict()
+        dtypes = {}
         for n, dtype in [
             ("float", np.float64),
             ("int", np.int64),

pandas/tests/frame/methods/test_to_records.py

@@ -131,128 +131,131 @@ def test_to_records_with_categorical(self):
         [
             # No dtypes --> default to array dtypes.
             (
-                dict(),
+                {},
                 np.rec.array(
                     [(0, 1, 0.2, "a"), (1, 2, 1.5, "bc")],
                     dtype=[("index", "<i8"), ("A", "<i8"), ("B", "<f8"), ("C", "O")],
                 ),
             ),
             # Should have no effect in this case.
             (
-                dict(index=True),
+                {"index": True},
                 np.rec.array(
                     [(0, 1, 0.2, "a"), (1, 2, 1.5, "bc")],
                     dtype=[("index", "<i8"), ("A", "<i8"), ("B", "<f8"), ("C", "O")],
                 ),
             ),
             # Column dtype applied across the board. Index unaffected.
             (
-                dict(column_dtypes="<U4"),
+                {"column_dtypes": "<U4"},
                 np.rec.array(
                     [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
                     dtype=[("index", "<i8"), ("A", "<U4"), ("B", "<U4"), ("C", "<U4")],
                 ),
             ),
             # Index dtype applied across the board. Columns unaffected.
             (
-                dict(index_dtypes="<U1"),
+                {"index_dtypes": "<U1"},
                 np.rec.array(
                     [("0", 1, 0.2, "a"), ("1", 2, 1.5, "bc")],
                     dtype=[("index", "<U1"), ("A", "<i8"), ("B", "<f8"), ("C", "O")],
                 ),
             ),
             # Pass in a type instance.
             (
-                dict(column_dtypes=str),
+                {"column_dtypes": str},
                 np.rec.array(
                     [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
                     dtype=[("index", "<i8"), ("A", "<U"), ("B", "<U"), ("C", "<U")],
                 ),
             ),
             # Pass in a dtype instance.
             (
-                dict(column_dtypes=np.dtype("unicode")),
+                {"column_dtypes": np.dtype("unicode")},
                 np.rec.array(
                     [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
                     dtype=[("index", "<i8"), ("A", "<U"), ("B", "<U"), ("C", "<U")],
                 ),
             ),
             # Pass in a dictionary (name-only).
             (
-                dict(column_dtypes={"A": np.int8, "B": np.float32, "C": "<U2"}),
+                {"column_dtypes": {"A": np.int8, "B": np.float32, "C": "<U2"}},
                 np.rec.array(
                     [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
                     dtype=[("index", "<i8"), ("A", "i1"), ("B", "<f4"), ("C", "<U2")],
                 ),
             ),
             # Pass in a dictionary (indices-only).
             (
-                dict(index_dtypes={0: "int16"}),
+                {"index_dtypes": {0: "int16"}},
                 np.rec.array(
                     [(0, 1, 0.2, "a"), (1, 2, 1.5, "bc")],
                     dtype=[("index", "i2"), ("A", "<i8"), ("B", "<f8"), ("C", "O")],
                 ),
             ),
             # Ignore index mappings if index is not True.
             (
-                dict(index=False, index_dtypes="<U2"),
+                {"index": False, "index_dtypes": "<U2"},
                 np.rec.array(
                     [(1, 0.2, "a"), (2, 1.5, "bc")],
                     dtype=[("A", "<i8"), ("B", "<f8"), ("C", "O")],
                 ),
             ),
             # Non-existent names / indices in mapping should not error.
             (
-                dict(index_dtypes={0: "int16", "not-there": "float32"}),
+                {"index_dtypes": {0: "int16", "not-there": "float32"}},
                 np.rec.array(
                     [(0, 1, 0.2, "a"), (1, 2, 1.5, "bc")],
                     dtype=[("index", "i2"), ("A", "<i8"), ("B", "<f8"), ("C", "O")],
                 ),
             ),
             # Names / indices not in mapping default to array dtype.
             (
-                dict(column_dtypes={"A": np.int8, "B": np.float32}),
+                {"column_dtypes": {"A": np.int8, "B": np.float32}},
                 np.rec.array(
                     [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
                     dtype=[("index", "<i8"), ("A", "i1"), ("B", "<f4"), ("C", "O")],
                 ),
             ),
             # Names / indices not in dtype mapping default to array dtype.
             (
-                dict(column_dtypes={"A": np.dtype("int8"), "B": np.dtype("float32")}),
+                {"column_dtypes": {"A": np.dtype("int8"), "B": np.dtype("float32")}},
                 np.rec.array(
                     [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
                     dtype=[("index", "<i8"), ("A", "i1"), ("B", "<f4"), ("C", "O")],
                 ),
             ),
             # Mixture of everything.
             (
-                dict(column_dtypes={"A": np.int8, "B": np.float32}, index_dtypes="<U2"),
+                {
+                    "column_dtypes": {"A": np.int8, "B": np.float32},
+                    "index_dtypes": "<U2",
+                },
                 np.rec.array(
                     [("0", "1", "0.2", "a"), ("1", "2", "1.5", "bc")],
                     dtype=[("index", "<U2"), ("A", "i1"), ("B", "<f4"), ("C", "O")],
                 ),
             ),
             # Invalid dype values.
             (
-                dict(index=False, column_dtypes=list()),
+                {"index": False, "column_dtypes": list()},
                 (ValueError, "Invalid dtype \\[\\] specified for column A"),
             ),
             (
-                dict(index=False, column_dtypes={"A": "int32", "B": 5}),
+                {"index": False, "column_dtypes": {"A": "int32", "B": 5}},
                 (ValueError, "Invalid dtype 5 specified for column B"),
             ),
             # Numpy can't handle EA types, so check error is raised
             (
-                dict(
-                    index=False,
-                    column_dtypes={"A": "int32", "B": CategoricalDtype(["a", "b"])},
-                ),
+                {
+                    "index": False,
+                    "column_dtypes": {"A": "int32", "B": CategoricalDtype(["a", "b"])},
+                },
                 (ValueError, "Invalid dtype category specified for column B"),
             ),
             # Check that bad types raise
             (
-                dict(index=False, column_dtypes={"A": "int32", "B": "foo"}),
+                {"index": False, "column_dtypes": {"A": "int32", "B": "foo"}},
                 (TypeError, "data type [\"']foo[\"'] not understood"),
             ),
         ],
@@ -276,7 +279,7 @@ def test_to_records_dtype(self, kwargs, expected):
                 DataFrame(
                     [[1, 2, 3], [4, 5, 6], [7, 8, 9]], columns=list("abc")
                 ).set_index(["a", "b"]),
-                dict(column_dtypes="float64", index_dtypes={0: "int32", 1: "int8"}),
+                {"column_dtypes": "float64", "index_dtypes": {0: "int32", 1: "int8"}},
                 np.rec.array(
                     [(1, 2, 3.0), (4, 5, 6.0), (7, 8, 9.0)],
                     dtype=[("a", "<i4"), ("b", "i1"), ("c", "<f8")],
@@ -290,7 +293,7 @@ def test_to_records_dtype(self, kwargs, expected):
                         [("a", "d"), ("b", "e"), ("c", "f")]
                     ),
                 ),
-                dict(column_dtypes={0: "<U1", 2: "float32"}, index_dtypes="float32"),
+                {"column_dtypes": {0: "<U1", 2: "float32"}, "index_dtypes": "float32"},
                 np.rec.array(
                     [(0.0, "1", 2, 3.0), (1.0, "4", 5, 6.0), (2.0, "7", 8, 9.0)],
                     dtype=[
@@ -312,7 +315,7 @@ def test_to_records_dtype(self, kwargs, expected):
                         [("d", -4), ("d", -5), ("f", -6)], names=list("cd")
                     ),
                 ),
-                dict(column_dtypes="float64", index_dtypes={0: "<U2", 1: "int8"}),
+                {"column_dtypes": "float64", "index_dtypes": {0: "<U2", 1: "int8"}},
                 np.rec.array(
                     [
                         ("d", -4, 1.0, 2.0, 3.0),
@@ -352,10 +355,10 @@ def keys(self):
 
         df = DataFrame({"A": [1, 2], "B": [0.2, 1.5], "C": ["a", "bc"]})
 
-        dtype_mappings = dict(
-            column_dtypes=DictLike(**{"A": np.int8, "B": np.float32}),
-            index_dtypes="<U2",
-        )
+        dtype_mappings = {
+            "column_dtypes": DictLike(**{"A": np.int8, "B": np.float32}),
+            "index_dtypes": "<U2",
+        }
 
         result = df.to_records(**dtype_mappings)
         expected = np.rec.array(