self.df = DataFrame(np.random.randn(1000, 100))
 
         self.s = Series(np.arange(1028.0))
-        self.df2 = DataFrame(dict.fromkeys(range(1028), self.s))
+        self.df2 = DataFrame({i: self.s for i in range(1028)})
         self.df3 = DataFrame(np.random.randn(1000, 3), columns=list("ABC"))
 
     def time_apply_user_func(self):

 )
 
 __all__ = [
+    "interchange",
     "extensions",
     "indexers",
-    "interchange",
     "types",
     "typing",
 ]

 )
 
 __all__ = [
-    "ExtensionArray",
-    "ExtensionDtype",
-    "ExtensionScalarOpsMixin",
     "no_default",
-    "register_dataframe_accessor",
+    "ExtensionDtype",
     "register_extension_dtype",
+    "register_dataframe_accessor",
     "register_index_accessor",
     "register_series_accessor",
     "take",
+    "ExtensionArray",
+    "ExtensionScalarOpsMixin",
 ]

 )
 
 __all__ = [
+    "check_array_indexer",
     "BaseIndexer",
     "FixedForwardWindowIndexer",
     "VariableOffsetWindowIndexer",
-    "check_array_indexer",
 ]

 from pandas.core.interchange.dataframe_protocol import DataFrame
 from pandas.core.interchange.from_dataframe import from_dataframe
 
-__all__ = ["DataFrame", "from_dataframe"]
+__all__ = ["from_dataframe", "DataFrame"]

 )
 
 __all__ = [
+    "infer_dtype",
+    "union_categoricals",
     "CategoricalDtype",
     "DatetimeTZDtype",
     "IntervalDtype",
     "PeriodDtype",
-    "infer_dtype",
-    "union_categoricals",
 ]

     "ExponentialMovingWindow",
     "ExponentialMovingWindowGroupby",
     "JsonReader",
-    "NAType",
     "NaTType",
+    "NAType",
     "PeriodIndexResamplerGroupby",
     "Resampler",
     "Rolling",
     "RollingGroupby",
     "SeriesGroupBy",
     "StataReader",
-    "TimeGrouper",
     # See TODO above
     # "Styler",
     "TimedeltaIndexResamplerGroupby",
+    "TimeGrouper",
     "Window",
 ]

     """Converts numba UnicodeCharSeq (numpy string scalar) -> unicode type (string).
     Is a no-op for other types."""
     if isinstance(x, types.UnicodeCharSeq):
-        return str
+        return lambda x: str(x)
     else:
         return lambda x: x
 

 )
 
 __all__ = [
+    "sliding_mean",
     "grouped_mean",
-    "grouped_min_max",
+    "sliding_sum",
     "grouped_sum",
+    "sliding_var",
     "grouped_var",
-    "sliding_mean",
     "sliding_min_max",
-    "sliding_sum",
-    "sliding_var",
+    "grouped_min_max",
 ]

     elif isinstance(key, list):
         # check if np.array(key).dtype would be bool
         if len(key) > 0:
-            if type(key) is not list:
+            if type(key) is not list:  # noqa: E721
                 # GH#42461 cython will raise TypeError if we pass a subclass
                 key = list(key)
             return lib.is_bool_list(key)

 
 
 __all__ = [
-    "DT64NS_DTYPE",
-    "INT64_DTYPE",
-    "TD64NS_DTYPE",
     "classes",
+    "DT64NS_DTYPE",
     "ensure_float64",
     "ensure_python_int",
     "ensure_str",
     "infer_dtype_from_object",
+    "INT64_DTYPE",
     "is_1d_only_ea_dtype",
     "is_all_strings",
     "is_any_real_numeric_dtype",

     "is_unsigned_integer_dtype",
     "needs_i8_conversion",
     "pandas_dtype",
+    "TD64NS_DTYPE",
     "validate_all_hashable",
 ]

         possible
         """
         if (
-            (isinstance(string, str)
-            and (string.startswith(("period[", "Period["))))
+            isinstance(string, str)
+            and (string.startswith(("period[", "Period[")))
             or isinstance(string, BaseOffset)
         ):
             # do not parse string like U as period[U]

                 # i.e. we want to treat any floating-point NaN as equal, but
                 # not a floating-point NaN and a datetime NaT.
                 fill_value = (
-                    (other._is_na_fill_value
-                    and isinstance(self.fill_value, type(other.fill_value)))
+                    other._is_na_fill_value
+                    and isinstance(self.fill_value, type(other.fill_value))
                     or isinstance(other.fill_value, type(self.fill_value))
                 )
             else:

 __all__ = [
     "ARITHMETIC_BINOPS",
     "arithmetic_op",
-    "comp_method_OBJECT_ARRAY",
     "comparison_op",
-    "fill_binop",
-    "get_array_op",
-    "get_op_result_name",
+    "comp_method_OBJECT_ARRAY",
     "invalid_comparison",
+    "fill_binop",
     "kleene_and",
     "kleene_or",
     "kleene_xor",
     "logical_op",
     "make_flex_doc",
-    "maybe_prepare_scalar_for_op",
     "radd",
     "rand_",
     "rdiv",

     "rtruediv",
     "rxor",
     "unpack_zerodim_and_defer",
+    "get_op_result_name",
+    "maybe_prepare_scalar_for_op",
+    "get_array_op",
 ]

 def test_apply_broadcast_scalars_axis1(float_frame):
     result = float_frame.apply(np.mean, axis=1, result_type="broadcast")
     m = float_frame.mean(axis=1)
-    expected = DataFrame(dict.fromkeys(float_frame.columns, m))
+    expected = DataFrame({c: m for c in float_frame.columns})
     tm.assert_frame_equal(result, expected)
 
 

     )
     m = list(range(len(float_frame.index)))
     expected = DataFrame(
-        dict.fromkeys(float_frame.columns, m),
+        {c: m for c in float_frame.columns},
         dtype="float64",
         index=float_frame.index,
     )

 
 @pytest.mark.parametrize(
     "box",
-    [list, tuple, lambda x: np.array(x, dtype="int64")],
+    [lambda x: list(x), lambda x: tuple(x), lambda x: np.array(x, dtype="int64")],
     ids=["list", "tuple", "array"],
 )
 def test_consistency_for_boxed(box, int_frame_const_col):

             cat=("B", max),
             dat=("C", "min"),
             f=("B", np.sum),
-            kk=("B", min),
+            kk=("B", lambda x: min(x)),
         )
     expected = pd.DataFrame(
         {

     tm.assert_series_equal(result, expected)
 
 
-@pytest.mark.parametrize("func", [str, str])
+@pytest.mark.parametrize("func", [str, lambda x: str(x)])
 def test_apply_map_evaluate_lambdas_the_same(string_series, func, by_row):
     # test that we are evaluating row-by-row first if by_row="compat"
     # else vectorized evaluation

     # in the future, the result will be a Series class.
 
     with tm.assert_produces_warning(FutureWarning):
-        result = string_series.agg(type)
+        result = string_series.agg(lambda x: type(x))
     assert isinstance(result, Series) and len(result) == len(string_series)
 
     with tm.assert_produces_warning(FutureWarning):

 def test_series_apply_unpack_nested_data():
     # GH#55189
     ser = Series([[1, 2, 3], [4, 5, 6, 7]])
-    result = ser.apply(Series)
+    result = ser.apply(lambda x: Series(x))
     expected = DataFrame({0: [1.0, 4.0], 1: [2.0, 5.0], 2: [3.0, 6.0], 3: [np.nan, 7]})
     tm.assert_frame_equal(result, expected)

             lambda obj, ng: ng + obj,
             lambda obj, ng: obj - ng,
             lambda obj, ng: ng - obj,
-            lambda obj, ng: np.add(obj, ng),
+            np.add,
             lambda obj, ng: np.add(ng, obj),
-            lambda obj, ng: np.subtract(obj, ng),
+            np.subtract,
             lambda obj, ng: np.subtract(ng, obj),
         ],
     )

         tm.assert_equal(result, expected)
 
         # same thing buts let's be explicit about calling __rfloordiv__
-        result = td1.__rfloordiv__(scalar_td)
+        result = scalar_td // td1
         tm.assert_equal(result, expected)
 
     def test_td64arr_floordiv_int(self, box_with_array):

         xbox = get_upcast_box(tdi, ser)
         expected = tm.box_expected(expected, xbox)
 
-        result = ser.__rtruediv__(tdi)
+        result = tdi / ser
         if box is DataFrame:
             assert result is NotImplemented
         else:

     # GH#27910
     arr = SparseArray([0, 1], fill_value=0)
     df = pd.DataFrame([[1, 2], [3, 4]])
-    result = arr + df
+    result = arr.__add__(df)
     assert result is NotImplemented
 
 

 def test_add_strings(dtype):
     arr = pd.array(["a", "b", "c", "d"], dtype=dtype)
     df = pd.DataFrame([["t", "y", "v", "w"]], dtype=object)
-    assert arr + df is NotImplemented
+    assert arr.__add__(df) is NotImplemented
 
     result = arr + df
     expected = pd.DataFrame([["at", "by", "cv", "dw"]]).astype(dtype)

     arr = pd.array(["a", "b", np.nan, np.nan], dtype=dtype)
     df = pd.DataFrame([["x", np.nan, "y", np.nan]])
 
-    assert arr + df is NotImplemented
+    assert arr.__add__(df) is NotImplemented
 
     result = arr + df
     expected = pd.DataFrame([["ax", np.nan, np.nan, np.nan]]).astype(dtype)

         [
             lambda x: x.tolist(),
             lambda x: x.to_list(),
-            list,
-            lambda x: list(iter(x)),
+            lambda x: list(x),
+            lambda x: list(x.__iter__()),
         ],
         ids=["tolist", "to_list", "list", "iter"],
     )

         [
             lambda x: x.tolist(),
             lambda x: x.to_list(),
-            list,
-            lambda x: list(iter(x)),
+            lambda x: list(x),
+            lambda x: list(x.__iter__()),
         ],
         ids=["tolist", "to_list", "list", "iter"],
     )

         [
             lambda x: x.tolist(),
             lambda x: x.to_list(),
-            list,
-            lambda x: list(iter(x)),
+            lambda x: list(x),
+            lambda x: list(x.__iter__()),
         ],
         ids=["tolist", "to_list", "list", "iter"],
     )

 @pytest.mark.parametrize(
     "cons",
     [
-        TimedeltaIndex,
+        lambda x: TimedeltaIndex(x),
         lambda x: TimedeltaIndex(TimedeltaIndex(x)),
     ],
 )

 
 @pytest.mark.parametrize(
     "method",
-    [lambda ser: ser.values, np.asarray],
+    [lambda ser: ser.values, lambda ser: np.asarray(ser)],
     ids=["values", "asarray"],
 )
 def test_series_values(using_copy_on_write, method):

 
 @pytest.mark.parametrize(
     "method",
-    [lambda df: df.values, np.asarray],
+    [lambda df: df.values, lambda df: np.asarray(df)],
     ids=["values", "asarray"],
 )
 def test_dataframe_values(using_copy_on_write, method):

     arr = np.array([[1, 2], [3, 4]])
     df = DataFrame(arr, copy=copy)
 
-    if (using_copy_on_write and copy is not False) or copy is True:
+    if using_copy_on_write and copy is not False or copy is True:
         assert not np.shares_memory(get_array(df, 0), arr)
     else:
         assert np.shares_memory(get_array(df, 0), arr)

     "func",
     [
         lambda df1, df2, **kwargs: df1.merge(df2, **kwargs),
-        merge,
+        lambda df1, df2, **kwargs: merge(df1, df2, **kwargs),
     ],
 )
 def test_merge_on_key(using_copy_on_write, func):

         lambda idx: idx,
         lambda idx: idx.view(),
         lambda idx: idx.copy(),
-        list,
+        lambda idx: list(idx),
     ],
     ids=["identical", "view", "copy", "values"],
 )

 }
 
 
-@pytest.mark.parametrize("name1,dtype1", list(dtypes.items()), ids=str)
-@pytest.mark.parametrize("name2,dtype2", list(dtypes.items()), ids=str)
+@pytest.mark.parametrize("name1,dtype1", list(dtypes.items()), ids=lambda x: str(x))
+@pytest.mark.parametrize("name2,dtype2", list(dtypes.items()), ids=lambda x: str(x))
 def test_dtype_equal(name1, dtype1, name2, dtype2):
     # match equal to self, but not equal to other
     assert com.is_dtype_equal(dtype1, dtype1)

         assert not com.is_dtype_equal(dtype1, dtype2)
 
 
-@pytest.mark.parametrize("name,dtype", list(dtypes.items()), ids=str)
+@pytest.mark.parametrize("name,dtype", list(dtypes.items()), ids=lambda x: str(x))
 def test_pyarrow_string_import_error(name, dtype):
     # GH-44276
     assert not com.is_dtype_equal(dtype, "string[pyarrow]")

 
     def test_repr(self):
         cat = Categorical(pd.Index([1, 2, 3], dtype="int32"))
-        result = repr(cat.dtype)
+        result = cat.dtype.__repr__()
         expected = (
             "CategoricalDtype(categories=[1, 2, 3], ordered=False, "
             "categories_dtype=int32)"

     def test_from_records_dt64tz_frame(self):
         # GH#51162 don't lose tz when calling from_records with DataFrame input
         dti = date_range("2016-01-01", periods=10, tz="US/Pacific")
-        df = DataFrame(dict.fromkeys(range(4), dti))
+        df = DataFrame({i: dti for i in range(4)})
         with tm.assert_produces_warning(FutureWarning):
             res = DataFrame.from_records(df)
         tm.assert_frame_equal(res, df)

 
     def test_setitem_frame_float(self, float_frame):
         piece = float_frame.loc[float_frame.index[:2], ["A", "B"]]
-        float_frame.loc[float_frame.index[-2]:, ["A", "B"]] = piece.values
+        float_frame.loc[float_frame.index[-2] :, ["A", "B"]] = piece.values
         result = float_frame.loc[float_frame.index[-2:], ["A", "B"]].values
         expected = piece.values
         tm.assert_almost_equal(result, expected)

         df.loc[df.index[:3], "E"] = np.array([5 * one_hour] * 3, dtype="m8[ns]")
         df["F"] = np.timedelta64("NaT")
         df.loc[df.index[:-1], "F"] = np.array([6 * one_hour] * 3, dtype="m8[ns]")
-        df.loc[df.index[-3]:, "G"] = date_range("20130101", periods=3)
+        df.loc[df.index[-3] :, "G"] = date_range("20130101", periods=3)
         df["H"] = np.datetime64("NaT")
         result = df.dtypes
         expected = Series(

         result = df.nlargest(n, order)
         expected = df.sort_values(order, ascending=False).head(n)
         if Version(np.__version__) >= Version("1.25") and (
-            (order == ["a"] and n in (1, 2, 3, 4)) or (order == ["a", "b"]) and n == 5
+            (order == ["a"] and n in (1, 2, 3, 4)) or ((order == ["a", "b"]) and n == 5)
         ):
             request.applymarker(
                 pytest.mark.xfail(

 import pandas._testing as tm
 
 
-@pytest.fixture(
-    params=[["linear", "single"], ["nearest", "table"]], ids=lambda x: "-".join(x)
-)
+@pytest.fixture(params=[["linear", "single"], ["nearest", "table"]], ids="-".join)
 def interp_method(request):
     """(interpolation, method) arguments for quantile"""
     return request.param

         # wrong length
         msg = (
             f"Length mismatch: Expected axis has {len(obj)} elements, "
-            f"new values have {len(obj)-1} elements"
+            f"new values have {len(obj) - 1} elements"
         )
         with pytest.raises(ValueError, match=msg):
             obj.index = np.arange(len(obj) - 1)

             columns=["A", "B", "C"],
         )
 
-        result = df == None
+        result = df.__eq__(None)
         assert not result.any().any()
 
     def test_df_string_comparison(self):

     @pytest.mark.parametrize(
         "constructor",
         [
-            DataFrame,
+            lambda: DataFrame(),
             lambda: DataFrame(None),
             lambda: DataFrame(()),
             lambda: DataFrame([]),

         index1 = ["\u03c3", "\u03c4", "\u03c5", "\u03c6"]
         cols = ["\u03c8"]
         df = DataFrame(data, columns=cols, index=index1)
-        assert type(repr(df)) is str
+        assert type(df.__repr__()) is str  # noqa: E721
 
         ser = df[cols[0]]
-        assert type(repr(ser)) is str
+        assert type(ser.__repr__()) is str  # noqa: E721
 
     def test_repr_bytes_61_lines(self):
         # GH#12857

             columns=["first", "last", "variable", "value"],
         )
 
-        df.apply(check_row_subclass)
-        df.apply(check_row_subclass, axis=1)
+        df.apply(lambda x: check_row_subclass(x))
+        df.apply(lambda x: check_row_subclass(x), axis=1)
 
         expected = tm.SubclassedDataFrame(
             [

             columns=["first", "last", "variable", "value"],
         )
 
-        result = df.apply(stretch, axis=1)
+        result = df.apply(lambda x: stretch(x), axis=1)
         assert isinstance(result, tm.SubclassedDataFrame)
         tm.assert_frame_equal(result, expected)
 

             [5.5, 7.5],
         ),
         (
-            (("y", "A"), max),
+            (("y", "A"), lambda x: max(x)),
             (("y", "A"), lambda x: 1),
             (("y", "B"), np.mean),
             [1, 3],

 
 
 @pytest.mark.parametrize(
-    "func", [lambda s: s.mean(), np.mean, np.nanmean]
+    "func", [lambda s: s.mean(), lambda s: np.mean(s), lambda s: np.nanmean(s)]
 )
 def test_multiindex_custom_func(func):
     # GH 31777

             height_sqr_min=("height", lambda x: np.min(x**2)),
             height_max=("height", "max"),
             weight_max=("weight", "max"),
-            height_max_2=("height", np.max),
-            weight_min=("weight", np.min),
+            height_max_2=("height", lambda x: np.max(x)),
+            weight_min=("weight", lambda x: np.min(x)),
         )
         tm.assert_frame_equal(result1, expected)
 

             height_sqr_min=pd.NamedAgg(column="height", aggfunc=lambda x: np.min(x**2)),
             height_max=pd.NamedAgg(column="height", aggfunc="max"),
             weight_max=pd.NamedAgg(column="weight", aggfunc="max"),
-            height_max_2=pd.NamedAgg(column="height", aggfunc=np.max),
-            weight_min=pd.NamedAgg(column="weight", aggfunc=np.min),
+            height_max_2=pd.NamedAgg(column="height", aggfunc=lambda x: np.max(x)),
+            weight_min=pd.NamedAgg(column="weight", aggfunc=lambda x: np.min(x)),
         )
         tm.assert_frame_equal(result2, expected)
 

     result = g._cython_agg_general(op, alt=None, numeric_only=True)
 
     g = df.groupby(pd.cut(df[0], grps), observed=observed)
-    expected = g.agg(targop)
+    expected = g.agg(lambda x: targop(x))
     tm.assert_frame_equal(result, expected)
 
 

     equiv_callables = [
         sum,
         np.sum,
-        sum,
+        lambda x: sum(x),
         lambda x: x.sum(),
         partial(sum),
         fn_class(),

     df = DataFrame({"a": 1, "b": [ts + dt.timedelta(minutes=nn) for nn in range(10)]})
 
     result1 = df.groupby("a")["b"].agg("min").iloc[0]
-    result2 = df.groupby("a")["b"].agg(np.min).iloc[0]
+    result2 = df.groupby("a")["b"].agg(lambda x: np.min(x)).iloc[0]
     result3 = df.groupby("a")["b"].min().iloc[0]
 
     assert result1 == ts

     [
         (tuple, tuple),
         (list, list),
-        (tuple, tuple),
-        (list, list),
+        (lambda x: tuple(x), tuple),
+        (lambda x: list(x), list),
     ],
 )
 def test_agg_structs_dataframe(structure, cast_as):

     [
         (tuple, tuple),
         (list, list),
-        (tuple, tuple),
-        (list, list),
+        (lambda x: tuple(x), tuple),
+        (lambda x: list(x), list),
     ],
 )
 def test_agg_structs_series(structure, cast_as):

     # GH 18473
     df = DataFrame({"A": [str(x) for x in range(3)], "B": [str(x) for x in range(3)]})
     grouped = df.groupby("A", as_index=False, sort=False)
-    result = grouped.agg({"B": list})
+    result = grouped.agg({"B": lambda x: list(x)})
     expected = DataFrame(
         {"A": [str(x) for x in range(3)], "B": [[str(x)] for x in range(3)]}
     )