diff --git a/pandas/tests/frame/test_query_eval.py b/pandas/tests/frame/test_query_eval.py
index 266b0e78e885e..feb912b2420bf 100644
--- a/pandas/tests/frame/test_query_eval.py
+++ b/pandas/tests/frame/test_query_eval.py
@@ -1094,20 +1094,18 @@ def test_query_string_scalar_variable(self, parser, engine):
 
 
 class TestDataFrameEvalWithFrame:
-    def setup_method(self):
-        self.frame = DataFrame(np.random.randn(10, 3), columns=list("abc"))
-
-    def teardown_method(self):
-        del self.frame
+    @pytest.fixture
+    def frame(self):
+        return DataFrame(np.random.randn(10, 3), columns=list("abc"))
 
-    def test_simple_expr(self, parser, engine):
-        res = self.frame.eval("a + b", engine=engine, parser=parser)
-        expect = self.frame.a + self.frame.b
+    def test_simple_expr(self, frame, parser, engine):
+        res = frame.eval("a + b", engine=engine, parser=parser)
+        expect = frame.a + frame.b
         tm.assert_series_equal(res, expect)
 
-    def test_bool_arith_expr(self, parser, engine):
-        res = self.frame.eval("a[a < 1] + b", engine=engine, parser=parser)
-        expect = self.frame.a[self.frame.a < 1] + self.frame.b
+    def test_bool_arith_expr(self, frame, parser, engine):
+        res = frame.eval("a[a < 1] + b", engine=engine, parser=parser)
+        expect = frame.a[frame.a < 1] + frame.b
         tm.assert_series_equal(res, expect)
 
     @pytest.mark.parametrize("op", ["+", "-", "*", "/"])
diff --git a/pandas/tests/indexes/datetimes/test_setops.py b/pandas/tests/indexes/datetimes/test_setops.py
index 4558fcccbb0e1..e92d726867f32 100644
--- a/pandas/tests/indexes/datetimes/test_setops.py
+++ b/pandas/tests/indexes/datetimes/test_setops.py
@@ -417,27 +417,25 @@ def test_intersection_non_tick_no_fastpath(self):
 
 
 class TestBusinessDatetimeIndex:
-    def setup_method(self):
-        self.rng = bdate_range(START, END)
-
     def test_union(self, sort):
+        rng = bdate_range(START, END)
         # overlapping
-        left = self.rng[:10]
-        right = self.rng[5:10]
+        left = rng[:10]
+        right = rng[5:10]
 
         the_union = left.union(right, sort=sort)
         assert isinstance(the_union, DatetimeIndex)
 
         # non-overlapping, gap in middle
-        left = self.rng[:5]
-        right = self.rng[10:]
+        left = rng[:5]
+        right = rng[10:]
 
         the_union = left.union(right, sort=sort)
         assert isinstance(the_union, Index)
 
         # non-overlapping, no gap
-        left = self.rng[:5]
-        right = self.rng[5:10]
+        left = rng[:5]
+        right = rng[5:10]
 
         the_union = left.union(right, sort=sort)
         assert isinstance(the_union, DatetimeIndex)
@@ -452,7 +450,7 @@ def test_union(self, sort):
         # overlapping, but different offset
         rng = date_range(START, END, freq=BMonthEnd())
 
-        the_union = self.rng.union(rng, sort=sort)
+        the_union = rng.union(rng, sort=sort)
         assert isinstance(the_union, DatetimeIndex)
 
     def test_union_not_cacheable(self, sort):
@@ -555,27 +553,25 @@ def test_intersection_duplicates(self, sort):
 
 
 class TestCustomDatetimeIndex:
-    def setup_method(self):
-        self.rng = bdate_range(START, END, freq="C")
-
     def test_union(self, sort):
         # overlapping
-        left = self.rng[:10]
-        right = self.rng[5:10]
+        rng = bdate_range(START, END, freq="C")
+        left = rng[:10]
+        right = rng[5:10]
 
         the_union = left.union(right, sort=sort)
         assert isinstance(the_union, DatetimeIndex)
 
         # non-overlapping, gap in middle
-        left = self.rng[:5]
-        right = self.rng[10:]
+        left = rng[:5]
+        right = rng[10:]
 
         the_union = left.union(right, sort)
         assert isinstance(the_union, Index)
 
         # non-overlapping, no gap
-        left = self.rng[:5]
-        right = self.rng[5:10]
+        left = rng[:5]
+        right = rng[5:10]
 
         the_union = left.union(right, sort=sort)
         assert isinstance(the_union, DatetimeIndex)
@@ -587,7 +583,7 @@ def test_union(self, sort):
         # overlapping, but different offset
         rng = date_range(START, END, freq=BMonthEnd())
 
-        the_union = self.rng.union(rng, sort=sort)
+        the_union = rng.union(rng, sort=sort)
         assert isinstance(the_union, DatetimeIndex)
 
     def test_intersection_bug(self):
diff --git a/pandas/tests/indexing/test_categorical.py b/pandas/tests/indexing/test_categorical.py
index eb38edd920082..b94323e975cd7 100644
--- a/pandas/tests/indexing/test_categorical.py
+++ b/pandas/tests/indexing/test_categorical.py
@@ -20,32 +20,37 @@
 from pandas.api.types import CategoricalDtype as CDT
 
 
-class TestCategoricalIndex:
-    def setup_method(self):
+@pytest.fixture
+def df():
+    return DataFrame(
+        {
+            "A": np.arange(6, dtype="int64"),
+        },
+        index=CategoricalIndex(list("aabbca"), dtype=CDT(list("cab")), name="B"),
+    )
+
+
+@pytest.fixture
+def df2():
+    return DataFrame(
+        {
+            "A": np.arange(6, dtype="int64"),
+        },
+        index=CategoricalIndex(list("aabbca"), dtype=CDT(list("cabe")), name="B"),
+    )
 
-        self.df = DataFrame(
-            {
-                "A": np.arange(6, dtype="int64"),
-            },
-            index=CategoricalIndex(list("aabbca"), dtype=CDT(list("cab")), name="B"),
-        )
-        self.df2 = DataFrame(
-            {
-                "A": np.arange(6, dtype="int64"),
-            },
-            index=CategoricalIndex(list("aabbca"), dtype=CDT(list("cabe")), name="B"),
-        )
 
-    def test_loc_scalar(self):
+class TestCategoricalIndex:
+    def test_loc_scalar(self, df):
         dtype = CDT(list("cab"))
-        result = self.df.loc["a"]
+        result = df.loc["a"]
         bidx = Series(list("aaa"), name="B").astype(dtype)
         assert bidx.dtype == dtype
 
         expected = DataFrame({"A": [0, 1, 5]}, index=Index(bidx))
         tm.assert_frame_equal(result, expected)
 
-        df = self.df.copy()
+        df = df.copy()
         df.loc["a"] = 20
         bidx2 = Series(list("aabbca"), name="B").astype(dtype)
         assert bidx2.dtype == dtype
@@ -68,9 +73,8 @@ def test_loc_scalar(self):
         df2.loc["d"] = 10
         tm.assert_frame_equal(df2, expected)
 
-    def test_loc_setitem_with_expansion_non_category(self):
+    def test_loc_setitem_with_expansion_non_category(self, df):
         # Setting-with-expansion with a new key "d" that is not among caegories
-        df = self.df
         df.loc["a"] = 20
 
         # Setting a new row on an existing column
@@ -97,9 +101,9 @@ def test_loc_setitem_with_expansion_non_category(self):
         )
         tm.assert_frame_equal(df4, expected3)
 
-    def test_loc_getitem_scalar_non_category(self):
+    def test_loc_getitem_scalar_non_category(self, df):
         with pytest.raises(KeyError, match="^1$"):
-            self.df.loc[1]
+            df.loc[1]
 
     def test_slicing(self):
         cat = Series(Categorical([1, 2, 3, 4]))
@@ -287,31 +291,31 @@ def test_slicing_doc_examples(self):
         )
         tm.assert_frame_equal(result, expected)
 
-    def test_loc_getitem_listlike_labels(self):
+    def test_loc_getitem_listlike_labels(self, df):
         # list of labels
-        result = self.df.loc[["c", "a"]]
-        expected = self.df.iloc[[4, 0, 1, 5]]
+        result = df.loc[["c", "a"]]
+        expected = df.iloc[[4, 0, 1, 5]]
         tm.assert_frame_equal(result, expected, check_index_type=True)
 
-    def test_loc_getitem_listlike_unused_category(self):
+    def test_loc_getitem_listlike_unused_category(self, df2):
         # GH#37901 a label that is in index.categories but not in index
         # listlike containing an element in the categories but not in the values
         with pytest.raises(KeyError, match=re.escape("['e'] not in index")):
-            self.df2.loc[["a", "b", "e"]]
+            df2.loc[["a", "b", "e"]]
 
-    def test_loc_getitem_label_unused_category(self):
+    def test_loc_getitem_label_unused_category(self, df2):
         # element in the categories but not in the values
         with pytest.raises(KeyError, match=r"^'e'$"):
-            self.df2.loc["e"]
+            df2.loc["e"]
 
-    def test_loc_getitem_non_category(self):
+    def test_loc_getitem_non_category(self, df2):
         # not all labels in the categories
         with pytest.raises(KeyError, match=re.escape("['d'] not in index")):
-            self.df2.loc[["a", "d"]]
+            df2.loc[["a", "d"]]
 
-    def test_loc_setitem_expansion_label_unused_category(self):
+    def test_loc_setitem_expansion_label_unused_category(self, df2):
         # assigning with a label that is in the categories but not in the index
-        df = self.df2.copy()
+        df = df2.copy()
         df.loc["e"] = 20
         result = df.loc[["a", "b", "e"]]
         exp_index = CategoricalIndex(list("aaabbe"), categories=list("cabe"), name="B")
@@ -450,17 +454,17 @@ def test_ix_categorical_index_non_unique(self):
         )
         tm.assert_frame_equal(cdf.loc[:, ["X", "Y"]], expect)
 
-    def test_loc_slice(self):
+    def test_loc_slice(self, df):
         # GH9748
         msg = (
             "cannot do slice indexing on CategoricalIndex with these "
             r"indexers \[1\] of type int"
         )
         with pytest.raises(TypeError, match=msg):
-            self.df.loc[1:5]
+            df.loc[1:5]
 
-        result = self.df.loc["b":"c"]
-        expected = self.df.iloc[[2, 3, 4]]
+        result = df.loc["b":"c"]
+        expected = df.iloc[[2, 3, 4]]
         tm.assert_frame_equal(result, expected)
 
     def test_loc_and_at_with_categorical_index(self):
diff --git a/pandas/tests/internals/test_internals.py b/pandas/tests/internals/test_internals.py
index f4060c84f533a..3c90eee5be999 100644
--- a/pandas/tests/internals/test_internals.py
+++ b/pandas/tests/internals/test_internals.py
@@ -243,13 +243,12 @@ def create_mgr(descr, item_shape=None):
     )
 
 
-class TestBlock:
-    def setup_method(self):
-        self.fblock = create_block("float", [0, 2, 4])
-        self.cblock = create_block("complex", [7])
-        self.oblock = create_block("object", [1, 3])
-        self.bool_block = create_block("bool", [5])
+@pytest.fixture
+def fblock():
+    return create_block("float", [0, 2, 4])
+
 
+class TestBlock:
     def test_constructor(self):
         int32block = create_block("i4", [0])
         assert int32block.dtype == np.int32
@@ -267,24 +266,24 @@ def test_pickle(self, typ, data):
         blk = create_block(typ, data)
         assert_block_equal(tm.round_trip_pickle(blk), blk)
 
-    def test_mgr_locs(self):
-        assert isinstance(self.fblock.mgr_locs, BlockPlacement)
+    def test_mgr_locs(self, fblock):
+        assert isinstance(fblock.mgr_locs, BlockPlacement)
         tm.assert_numpy_array_equal(
-            self.fblock.mgr_locs.as_array, np.array([0, 2, 4], dtype=np.intp)
+            fblock.mgr_locs.as_array, np.array([0, 2, 4], dtype=np.intp)
         )
 
-    def test_attrs(self):
-        assert self.fblock.shape == self.fblock.values.shape
-        assert self.fblock.dtype == self.fblock.values.dtype
-        assert len(self.fblock) == len(self.fblock.values)
+    def test_attrs(self, fblock):
+        assert fblock.shape == fblock.values.shape
+        assert fblock.dtype == fblock.values.dtype
+        assert len(fblock) == len(fblock.values)
 
-    def test_copy(self):
-        cop = self.fblock.copy()
-        assert cop is not self.fblock
-        assert_block_equal(self.fblock, cop)
+    def test_copy(self, fblock):
+        cop = fblock.copy()
+        assert cop is not fblock
+        assert_block_equal(fblock, cop)
 
-    def test_delete(self):
-        newb = self.fblock.copy()
+    def test_delete(self, fblock):
+        newb = fblock.copy()
         locs = newb.mgr_locs
         nb = newb.delete(0)
         assert newb.mgr_locs is locs
@@ -297,7 +296,7 @@ def test_delete(self):
         assert not (newb.values[0] == 1).all()
         assert (nb.values[0] == 1).all()
 
-        newb = self.fblock.copy()
+        newb = fblock.copy()
         locs = newb.mgr_locs
         nb = newb.delete(1)
         assert newb.mgr_locs is locs
@@ -308,7 +307,7 @@ def test_delete(self):
         assert not (newb.values[1] == 2).all()
         assert (nb.values[1] == 2).all()
 
-        newb = self.fblock.copy()
+        newb = fblock.copy()
         locs = newb.mgr_locs
         nb = newb.delete(2)
         tm.assert_numpy_array_equal(
@@ -316,7 +315,7 @@ def test_delete(self):
         )
         assert (nb.values[1] == 1).all()
 
-        newb = self.fblock.copy()
+        newb = fblock.copy()
 
         with pytest.raises(IndexError, match=None):
             newb.delete(3)
@@ -357,9 +356,9 @@ def test_split(self):
         for res, exp in zip(result, expected):
             assert_block_equal(res, exp)
 
-    def test_is_categorical_deprecated(self):
+    def test_is_categorical_deprecated(self, fblock):
         # GH#40571
-        blk = self.fblock
+        blk = fblock
         with tm.assert_produces_warning(DeprecationWarning):
             blk.is_categorical
 
diff --git a/pandas/tests/io/formats/style/test_style.py b/pandas/tests/io/formats/style/test_style.py
index 62608e2f17267..4615f3ff50cbd 100644
--- a/pandas/tests/io/formats/style/test_style.py
+++ b/pandas/tests/io/formats/style/test_style.py
@@ -6,7 +6,6 @@
 import pytest
 
 from pandas import (
-    Categorical,
     DataFrame,
     IndexSlice,
     MultiIndex,
@@ -80,6 +79,25 @@ def mi_styler_comp(mi_styler):
     return mi_styler
 
 
+@pytest.fixture
+def blank_value():
+    return "&nbsp;"
+
+
+@pytest.fixture
+def df():
+    np.random.seed(24)
+    df = DataFrame({"A": [0, 1], "B": np.random.randn(2)})
+    return df
+
+
+@pytest.fixture
+def styler(df):
+    np.random.seed(24)
+    df = DataFrame({"A": [0, 1], "B": np.random.randn(2)})
+    return Styler(df)
+
+
 @pytest.mark.parametrize(
     "sparse_columns, exp_cols",
     [
@@ -444,25 +462,6 @@ def test_apply_map_header_raises(mi_styler):
 
 
 class TestStyler:
-    def setup_method(self):
-        np.random.seed(24)
-        self.s = DataFrame({"A": np.random.permutation(range(6))})
-        self.df = DataFrame({"A": [0, 1], "B": np.random.randn(2)})
-        self.f = lambda x: x
-        self.g = lambda x: x
-
-        def h(x, foo="bar"):
-            return Series(f"color: {foo}", index=x.index, name=x.name)
-
-        self.h = h
-        self.styler = Styler(self.df)
-        self.attrs = DataFrame({"A": ["color: red", "color: blue"]})
-        self.dataframes = [
-            self.df,
-            DataFrame({"f": [1.0, 2.0], "o": ["a", "b"], "c": Categorical(["a", "b"])}),
-        ]
-        self.blank_value = "&nbsp;"
-
     def test_init_non_pandas(self):
         msg = "``data`` must be a Series or DataFrame"
         with pytest.raises(TypeError, match=msg):
@@ -472,29 +471,29 @@ def test_init_series(self):
         result = Styler(Series([1, 2]))
         assert result.data.ndim == 2
 
-    def test_repr_html_ok(self):
-        self.styler._repr_html_()
+    def test_repr_html_ok(self, styler):
+        styler._repr_html_()
 
-    def test_repr_html_mathjax(self):
+    def test_repr_html_mathjax(self, styler):
         # gh-19824 / 41395
-        assert "tex2jax_ignore" not in self.styler._repr_html_()
+        assert "tex2jax_ignore" not in styler._repr_html_()
 
         with option_context("styler.html.mathjax", False):
-            assert "tex2jax_ignore" in self.styler._repr_html_()
+            assert "tex2jax_ignore" in styler._repr_html_()
 
-    def test_update_ctx(self):
-        self.styler._update_ctx(self.attrs)
+    def test_update_ctx(self, styler):
+        styler._update_ctx(DataFrame({"A": ["color: red", "color: blue"]}))
         expected = {(0, 0): [("color", "red")], (1, 0): [("color", "blue")]}
-        assert self.styler.ctx == expected
+        assert styler.ctx == expected
 
-    def test_update_ctx_flatten_multi_and_trailing_semi(self):
+    def test_update_ctx_flatten_multi_and_trailing_semi(self, styler):
         attrs = DataFrame({"A": ["color: red; foo: bar", "color:blue ; foo: baz;"]})
-        self.styler._update_ctx(attrs)
+        styler._update_ctx(attrs)
         expected = {
             (0, 0): [("color", "red"), ("foo", "bar")],
             (1, 0): [("color", "blue"), ("foo", "baz")],
         }
-        assert self.styler.ctx == expected
+        assert styler.ctx == expected
 
     def test_render(self):
         df = DataFrame({"A": [0, 1]})
@@ -503,9 +502,9 @@ def test_render(self):
         s.to_html()
         # it worked?
 
-    def test_multiple_render(self):
+    def test_multiple_render(self, df):
         # GH 39396
-        s = Styler(self.df, uuid_len=0).applymap(lambda x: "color: red;", subset=["A"])
+        s = Styler(df, uuid_len=0).applymap(lambda x: "color: red;", subset=["A"])
         s.to_html()  # do 2 renders to ensure css styles not duplicated
         assert (
             '<style type="text/css">\n#T__row0_col0, #T__row1_col0 {\n'
@@ -551,7 +550,7 @@ def test_set_properties_subset(self):
         expected = {(0, 0): [("color", "white")]}
         assert result == expected
 
-    def test_empty_index_name_doesnt_display(self):
+    def test_empty_index_name_doesnt_display(self, blank_value):
         # https://github.com/pandas-dev/pandas/pull/12090#issuecomment-180695902
         df = DataFrame({"A": [1, 2], "B": [3, 4], "C": [5, 6]})
         result = df.style._translate(True, True)
@@ -559,9 +558,9 @@ def test_empty_index_name_doesnt_display(self):
         expected = {
             "class": "blank level0",
             "type": "th",
-            "value": self.blank_value,
+            "value": blank_value,
             "is_visible": True,
-            "display_value": self.blank_value,
+            "display_value": blank_value,
         }
         assert expected.items() <= result["head"][0][0].items()
 
@@ -657,17 +656,16 @@ def test_apply_dataframe_return(self, index, columns):
         ],
     )
     @pytest.mark.parametrize("axis", [0, 1])
-    def test_apply_subset(self, slice_, axis):
-        result = (
-            self.df.style.apply(self.h, axis=axis, subset=slice_, foo="baz")
-            ._compute()
-            .ctx
-        )
+    def test_apply_subset(self, slice_, axis, df):
+        def h(x, foo="bar"):
+            return Series(f"color: {foo}", index=x.index, name=x.name)
+
+        result = df.style.apply(h, axis=axis, subset=slice_, foo="baz")._compute().ctx
         expected = {
             (r, c): [("color", "baz")]
-            for r, row in enumerate(self.df.index)
-            for c, col in enumerate(self.df.columns)
-            if row in self.df.loc[slice_].index and col in self.df.loc[slice_].columns
+            for r, row in enumerate(df.index)
+            for c, col in enumerate(df.columns)
+            if row in df.loc[slice_].index and col in df.loc[slice_].columns
         }
         assert result == expected
 
@@ -681,15 +679,13 @@ def test_apply_subset(self, slice_, axis):
             IndexSlice[:2, ["A", "B"]],
         ],
     )
-    def test_applymap_subset(self, slice_):
-        result = (
-            self.df.style.applymap(lambda x: "color:baz;", subset=slice_)._compute().ctx
-        )
+    def test_applymap_subset(self, slice_, df):
+        result = df.style.applymap(lambda x: "color:baz;", subset=slice_)._compute().ctx
         expected = {
             (r, c): [("color", "baz")]
-            for r, row in enumerate(self.df.index)
-            for c, col in enumerate(self.df.columns)
-            if row in self.df.loc[slice_].index and col in self.df.loc[slice_].columns
+            for r, row in enumerate(df.index)
+            for c, col in enumerate(df.columns)
+            if row in df.loc[slice_].index and col in df.loc[slice_].columns
         }
         assert result == expected
 
@@ -781,22 +777,22 @@ def test_init_with_na_rep(self):
         assert ctx["body"][0][1]["display_value"] == "NA"
         assert ctx["body"][0][2]["display_value"] == "NA"
 
-    def test_caption(self):
-        styler = Styler(self.df, caption="foo")
+    def test_caption(self, df):
+        styler = Styler(df, caption="foo")
         result = styler.to_html()
         assert all(["caption" in result, "foo" in result])
 
-        styler = self.df.style
+        styler = df.style
         result = styler.set_caption("baz")
         assert styler is result
         assert styler.caption == "baz"
 
-    def test_uuid(self):
-        styler = Styler(self.df, uuid="abc123")
+    def test_uuid(self, df):
+        styler = Styler(df, uuid="abc123")
         result = styler.to_html()
         assert "abc123" in result
 
-        styler = self.df.style
+        styler = df.style
         result = styler.set_uuid("aaa")
         assert result is styler
         assert result.uuid == "aaa"
@@ -809,25 +805,25 @@ def test_unique_id(self):
         ids = re.findall('id="(.*?)"', result)
         assert np.unique(ids).size == len(ids)
 
-    def test_table_styles(self):
+    def test_table_styles(self, df):
         style = [{"selector": "th", "props": [("foo", "bar")]}]  # default format
-        styler = Styler(self.df, table_styles=style)
+        styler = Styler(df, table_styles=style)
         result = " ".join(styler.to_html().split())
         assert "th { foo: bar; }" in result
 
-        styler = self.df.style
+        styler = df.style
         result = styler.set_table_styles(style)
         assert styler is result
         assert styler.table_styles == style
 
         # GH 39563
         style = [{"selector": "th", "props": "foo:bar;"}]  # css string format
-        styler = self.df.style.set_table_styles(style)
+        styler = df.style.set_table_styles(style)
         result = " ".join(styler.to_html().split())
         assert "th { foo: bar; }" in result
 
-    def test_table_styles_multiple(self):
-        ctx = self.df.style.set_table_styles(
+    def test_table_styles_multiple(self, df):
+        ctx = df.style.set_table_styles(
             [
                 {"selector": "th,td", "props": "color:red;"},
                 {"selector": "tr", "props": "color:green;"},
@@ -839,9 +835,9 @@ def test_table_styles_multiple(self):
             {"selector": "tr", "props": [("color", "green")]},
         ]
 
-    def test_table_styles_dict_multiple_selectors(self):
+    def test_table_styles_dict_multiple_selectors(self, df):
         # GH 44011
-        result = self.df.style.set_table_styles(
+        result = df.style.set_table_styles(
             {
                 "B": [
                     {"selector": "th,td", "props": [("border-left", "2px solid black")]}
@@ -868,13 +864,13 @@ def test_maybe_convert_css_to_tuples_err(self):
         with pytest.raises(ValueError, match=msg):
             maybe_convert_css_to_tuples("err")
 
-    def test_table_attributes(self):
+    def test_table_attributes(self, df):
         attributes = 'class="foo" data-bar'
-        styler = Styler(self.df, table_attributes=attributes)
+        styler = Styler(df, table_attributes=attributes)
         result = styler.to_html()
         assert 'class="foo" data-bar' in result
 
-        result = self.df.style.set_table_attributes(attributes).to_html()
+        result = df.style.set_table_attributes(attributes).to_html()
         assert 'class="foo" data-bar' in result
 
     def test_apply_none(self):
@@ -888,20 +884,20 @@ def f(x):
         result = DataFrame([[1, 2], [3, 4]]).style.apply(f, axis=None)._compute().ctx
         assert result[(1, 1)] == [("color", "red")]
 
-    def test_trim(self):
-        result = self.df.style.to_html()  # trim=True
+    def test_trim(self, df):
+        result = df.style.to_html()  # trim=True
         assert result.count("#") == 0
 
-        result = self.df.style.highlight_max().to_html()
-        assert result.count("#") == len(self.df.columns)
+        result = df.style.highlight_max().to_html()
+        assert result.count("#") == len(df.columns)
 
-    def test_export(self):
+    def test_export(self, df, styler):
         f = lambda x: "color: red" if x > 0 else "color: blue"
         g = lambda x, z: f"color: {z}" if x > 0 else f"color: {z}"
-        style1 = self.styler
+        style1 = styler
         style1.applymap(f).applymap(g, z="b").highlight_max()._compute()  # = render
         result = style1.export()
-        style2 = self.df.style
+        style2 = df.style
         style2.use(result)
         assert style1._todo == style2._todo
         style2.to_html()
@@ -1014,7 +1010,7 @@ def test_get_level_lengths_un_sorted(self):
         result = _get_level_lengths(index, sparsify=False, max_index=100)
         tm.assert_dict_equal(result, expected)
 
-    def test_mi_sparse_index_names(self):
+    def test_mi_sparse_index_names(self, blank_value):
         # Test the class names and displayed value are correct on rendering MI names
         df = DataFrame(
             {"A": [1, 2]},
@@ -1037,14 +1033,14 @@ def test_mi_sparse_index_names(self):
             },
             {
                 "class": "blank col0",
-                "display_value": self.blank_value,
+                "display_value": blank_value,
                 "is_visible": True,
             },
         ]
         for i, expected_dict in enumerate(expected):
             assert expected_dict.items() <= head[i].items()
 
-    def test_mi_sparse_column_names(self):
+    def test_mi_sparse_column_names(self, blank_value):
         df = DataFrame(
             np.arange(16).reshape(4, 4),
             index=MultiIndex.from_arrays(
@@ -1062,7 +1058,7 @@ def test_mi_sparse_column_names(self):
             expected = [
                 {
                     "class": "blank",
-                    "display_value": self.blank_value,
+                    "display_value": blank_value,
                     "is_visible": True,
                 },
                 {
@@ -1074,32 +1070,32 @@ def test_mi_sparse_column_names(self):
             for i, expected_dict in enumerate(expected):
                 assert expected_dict.items() <= head[i].items()
 
-    def test_hide_column_headers(self):
-        ctx = self.styler.hide(axis="columns")._translate(True, True)
+    def test_hide_column_headers(self, df, styler):
+        ctx = styler.hide(axis="columns")._translate(True, True)
         assert len(ctx["head"]) == 0  # no header entries with an unnamed index
 
-        self.df.index.name = "some_name"
-        ctx = self.df.style.hide(axis="columns")._translate(True, True)
+        df.index.name = "some_name"
+        ctx = df.style.hide(axis="columns")._translate(True, True)
         assert len(ctx["head"]) == 1
         # index names still visible, changed in #42101, reverted in 43404
 
-    def test_hide_single_index(self):
+    def test_hide_single_index(self, df):
         # GH 14194
         # single unnamed index
-        ctx = self.df.style._translate(True, True)
+        ctx = df.style._translate(True, True)
         assert ctx["body"][0][0]["is_visible"]
         assert ctx["head"][0][0]["is_visible"]
-        ctx2 = self.df.style.hide(axis="index")._translate(True, True)
+        ctx2 = df.style.hide(axis="index")._translate(True, True)
         assert not ctx2["body"][0][0]["is_visible"]
         assert not ctx2["head"][0][0]["is_visible"]
 
         # single named index
-        ctx3 = self.df.set_index("A").style._translate(True, True)
+        ctx3 = df.set_index("A").style._translate(True, True)
         assert ctx3["body"][0][0]["is_visible"]
         assert len(ctx3["head"]) == 2  # 2 header levels
         assert ctx3["head"][0][0]["is_visible"]
 
-        ctx4 = self.df.set_index("A").style.hide(axis="index")._translate(True, True)
+        ctx4 = df.set_index("A").style.hide(axis="index")._translate(True, True)
         assert not ctx4["body"][0][0]["is_visible"]
         assert len(ctx4["head"]) == 1  # only 1 header levels
         assert not ctx4["head"][0][0]["is_visible"]
@@ -1127,10 +1123,10 @@ def test_hide_multiindex(self):
         assert len(ctx2["head"][0]) == 3  # one hidden (col name) and two data columns
         assert not ctx2["head"][0][0]["is_visible"]
 
-    def test_hide_columns_single_level(self):
+    def test_hide_columns_single_level(self, df):
         # GH 14194
         # test hiding single column
-        ctx = self.df.style._translate(True, True)
+        ctx = df.style._translate(True, True)
         assert ctx["head"][0][1]["is_visible"]
         assert ctx["head"][0][1]["display_value"] == "A"
         assert ctx["head"][0][2]["is_visible"]
@@ -1138,13 +1134,13 @@ def test_hide_columns_single_level(self):
         assert ctx["body"][0][1]["is_visible"]  # col A, row 1
         assert ctx["body"][1][2]["is_visible"]  # col B, row 1
 
-        ctx = self.df.style.hide("A", axis="columns")._translate(True, True)
+        ctx = df.style.hide("A", axis="columns")._translate(True, True)
         assert not ctx["head"][0][1]["is_visible"]
         assert not ctx["body"][0][1]["is_visible"]  # col A, row 1
         assert ctx["body"][1][2]["is_visible"]  # col B, row 1
 
         # test hiding mulitiple columns
-        ctx = self.df.style.hide(["A", "B"], axis="columns")._translate(True, True)
+        ctx = df.style.hide(["A", "B"], axis="columns")._translate(True, True)
         assert not ctx["head"][0][1]["is_visible"]
         assert not ctx["head"][0][2]["is_visible"]
         assert not ctx["body"][0][1]["is_visible"]  # col A, row 1
@@ -1210,18 +1206,18 @@ def test_hide_columns_index_mult_levels(self):
             assert "row1" in ctx["body"][0][i]["class"]  # row0 not included in body
             assert ctx["body"][0][i]["is_visible"]
 
-    def test_pipe(self):
+    def test_pipe(self, df):
         def set_caption_from_template(styler, a, b):
             return styler.set_caption(f"Dataframe with a = {a} and b = {b}")
 
-        styler = self.df.style.pipe(set_caption_from_template, "A", b="B")
+        styler = df.style.pipe(set_caption_from_template, "A", b="B")
         assert "Dataframe with a = A and b = B" in styler.to_html()
 
         # Test with an argument that is a (callable, keyword_name) pair.
         def f(a, b, styler):
             return (a, b, styler)
 
-        styler = self.df.style
+        styler = df.style
         result = styler.pipe((f, "styler"), a=1, b=2)
         assert result == (1, 2, styler)
 
diff --git a/pandas/tests/io/formats/test_format.py b/pandas/tests/io/formats/test_format.py
index 9ab3e4cf6afac..3c807a0ad0567 100644
--- a/pandas/tests/io/formats/test_format.py
+++ b/pandas/tests/io/formats/test_format.py
@@ -2110,9 +2110,6 @@ def gen_series_formatting():
 
 
 class TestSeriesFormatting:
-    def setup_method(self):
-        self.ts = tm.makeTimeSeries()
-
     def test_repr_unicode(self):
         s = Series(["\u03c3"] * 10)
         repr(s)
@@ -2122,30 +2119,31 @@ def test_repr_unicode(self):
         repr(a)
 
     def test_to_string(self):
+        ts = tm.makeTimeSeries()
         buf = StringIO()
 
-        s = self.ts.to_string()
+        s = ts.to_string()
 
-        retval = self.ts.to_string(buf=buf)
+        retval = ts.to_string(buf=buf)
         assert retval is None
         assert buf.getvalue().strip() == s
 
         # pass float_format
         format = "%.4f".__mod__
-        result = self.ts.to_string(float_format=format)
+        result = ts.to_string(float_format=format)
         result = [x.split()[1] for x in result.split("\n")[:-1]]
-        expected = [format(x) for x in self.ts]
+        expected = [format(x) for x in ts]
         assert result == expected
 
         # empty string
-        result = self.ts[:0].to_string()
+        result = ts[:0].to_string()
         assert result == "Series([], Freq: B)"
 
-        result = self.ts[:0].to_string(length=0)
+        result = ts[:0].to_string(length=0)
         assert result == "Series([], Freq: B)"
 
         # name and length
-        cp = self.ts.copy()
+        cp = ts.copy()
         cp.name = "foo"
         result = cp.to_string(length=True, name=True, dtype=True)
         last_line = result.split("\n")[-1].strip()
diff --git a/pandas/tests/io/json/test_json_table_schema_ext_dtype.py b/pandas/tests/io/json/test_json_table_schema_ext_dtype.py
index f6aa16ff0ce38..f31262a1eacfd 100644
--- a/pandas/tests/io/json/test_json_table_schema_ext_dtype.py
+++ b/pandas/tests/io/json/test_json_table_schema_ext_dtype.py
@@ -30,22 +30,16 @@
 
 
 class TestBuildSchema:
-    def setup_method(self):
-        self.da = DateArray([dt.date(2021, 10, 10)])
-        self.dc = DecimalArray([decimal.Decimal(10)])
-        self.sa = array(["pandas"], dtype="string")
-        self.ia = array([10], dtype="Int64")
-        self.df = DataFrame(
+    def test_build_table_schema(self):
+        df = DataFrame(
             {
-                "A": self.da,
-                "B": self.dc,
-                "C": self.sa,
-                "D": self.ia,
+                "A": DateArray([dt.date(2021, 10, 10)]),
+                "B": DecimalArray([decimal.Decimal(10)]),
+                "C": array(["pandas"], dtype="string"),
+                "D": array([10], dtype="Int64"),
             }
         )
-
-    def test_build_table_schema(self):
-        result = build_table_schema(self.df, version=False)
+        result = build_table_schema(df, version=False)
         expected = {
             "fields": [
                 {"name": "index", "type": "integer"},
@@ -57,7 +51,7 @@ def test_build_table_schema(self):
             "primaryKey": ["index"],
         }
         assert result == expected
-        result = build_table_schema(self.df)
+        result = build_table_schema(df)
         assert "pandas_version" in result
 
 
diff --git a/pandas/tests/io/test_sql.py b/pandas/tests/io/test_sql.py
index e4318f1d79102..e28901fa1a1ed 100644
--- a/pandas/tests/io/test_sql.py
+++ b/pandas/tests/io/test_sql.py
@@ -650,7 +650,7 @@ def psql_insert_copy(table, conn, keys, data_iter):
 
 
 class MixInBase:
-    def teardown_method(self, method):
+    def teardown_method(self):
         # if setup fails, there may not be a connection to close.
         if hasattr(self, "conn"):
             for tbl in self._get_all_tables():
diff --git a/pandas/tests/plotting/test_converter.py b/pandas/tests/plotting/test_converter.py
index 0258d2fae116d..656969bfad703 100644
--- a/pandas/tests/plotting/test_converter.py
+++ b/pandas/tests/plotting/test_converter.py
@@ -154,40 +154,40 @@ def test_registry_resets(self):
 
 
 class TestDateTimeConverter:
-    def setup_method(self):
-        self.dtc = converter.DatetimeConverter()
-        self.tc = converter.TimeFormatter(None)
+    @pytest.fixture
+    def dtc(self):
+        return converter.DatetimeConverter()
 
-    def test_convert_accepts_unicode(self):
-        r1 = self.dtc.convert("12:22", None, None)
-        r2 = self.dtc.convert("12:22", None, None)
+    def test_convert_accepts_unicode(self, dtc):
+        r1 = dtc.convert("12:22", None, None)
+        r2 = dtc.convert("12:22", None, None)
         assert r1 == r2, "DatetimeConverter.convert should accept unicode"
 
-    def test_conversion(self):
-        rs = self.dtc.convert(["2012-1-1"], None, None)[0]
+    def test_conversion(self, dtc):
+        rs = dtc.convert(["2012-1-1"], None, None)[0]
         xp = dates.date2num(datetime(2012, 1, 1))
         assert rs == xp
 
-        rs = self.dtc.convert("2012-1-1", None, None)
+        rs = dtc.convert("2012-1-1", None, None)
         assert rs == xp
 
-        rs = self.dtc.convert(date(2012, 1, 1), None, None)
+        rs = dtc.convert(date(2012, 1, 1), None, None)
         assert rs == xp
 
-        rs = self.dtc.convert("2012-1-1", None, None)
+        rs = dtc.convert("2012-1-1", None, None)
         assert rs == xp
 
-        rs = self.dtc.convert(Timestamp("2012-1-1"), None, None)
+        rs = dtc.convert(Timestamp("2012-1-1"), None, None)
         assert rs == xp
 
         # also testing datetime64 dtype (GH8614)
-        rs = self.dtc.convert("2012-01-01", None, None)
+        rs = dtc.convert("2012-01-01", None, None)
         assert rs == xp
 
-        rs = self.dtc.convert("2012-01-01 00:00:00+0000", None, None)
+        rs = dtc.convert("2012-01-01 00:00:00+0000", None, None)
         assert rs == xp
 
-        rs = self.dtc.convert(
+        rs = dtc.convert(
             np.array(["2012-01-01 00:00:00+0000", "2012-01-02 00:00:00+0000"]),
             None,
             None,
@@ -197,48 +197,48 @@ def test_conversion(self):
         # we have a tz-aware date (constructed to that when we turn to utc it
         # is the same as our sample)
         ts = Timestamp("2012-01-01").tz_localize("UTC").tz_convert("US/Eastern")
-        rs = self.dtc.convert(ts, None, None)
+        rs = dtc.convert(ts, None, None)
         assert rs == xp
 
-        rs = self.dtc.convert(ts.to_pydatetime(), None, None)
+        rs = dtc.convert(ts.to_pydatetime(), None, None)
         assert rs == xp
 
-        rs = self.dtc.convert(Index([ts - Day(1), ts]), None, None)
+        rs = dtc.convert(Index([ts - Day(1), ts]), None, None)
         assert rs[1] == xp
 
-        rs = self.dtc.convert(Index([ts - Day(1), ts]).to_pydatetime(), None, None)
+        rs = dtc.convert(Index([ts - Day(1), ts]).to_pydatetime(), None, None)
         assert rs[1] == xp
 
-    def test_conversion_float(self):
+    def test_conversion_float(self, dtc):
         rtol = 0.5 * 10**-9
 
-        rs = self.dtc.convert(Timestamp("2012-1-1 01:02:03", tz="UTC"), None, None)
+        rs = dtc.convert(Timestamp("2012-1-1 01:02:03", tz="UTC"), None, None)
         xp = converter.dates.date2num(Timestamp("2012-1-1 01:02:03", tz="UTC"))
         tm.assert_almost_equal(rs, xp, rtol=rtol)
 
-        rs = self.dtc.convert(
+        rs = dtc.convert(
             Timestamp("2012-1-1 09:02:03", tz="Asia/Hong_Kong"), None, None
         )
         tm.assert_almost_equal(rs, xp, rtol=rtol)
 
-        rs = self.dtc.convert(datetime(2012, 1, 1, 1, 2, 3), None, None)
+        rs = dtc.convert(datetime(2012, 1, 1, 1, 2, 3), None, None)
         tm.assert_almost_equal(rs, xp, rtol=rtol)
 
-    def test_conversion_outofbounds_datetime(self):
+    def test_conversion_outofbounds_datetime(self, dtc):
         # 2579
         values = [date(1677, 1, 1), date(1677, 1, 2)]
-        rs = self.dtc.convert(values, None, None)
+        rs = dtc.convert(values, None, None)
         xp = converter.dates.date2num(values)
         tm.assert_numpy_array_equal(rs, xp)
-        rs = self.dtc.convert(values[0], None, None)
+        rs = dtc.convert(values[0], None, None)
         xp = converter.dates.date2num(values[0])
         assert rs == xp
 
         values = [datetime(1677, 1, 1, 12), datetime(1677, 1, 2, 12)]
-        rs = self.dtc.convert(values, None, None)
+        rs = dtc.convert(values, None, None)
         xp = converter.dates.date2num(values)
         tm.assert_numpy_array_equal(rs, xp)
-        rs = self.dtc.convert(values[0], None, None)
+        rs = dtc.convert(values[0], None, None)
         xp = converter.dates.date2num(values[0])
         assert rs == xp
 
@@ -254,33 +254,33 @@ def test_conversion_outofbounds_datetime(self):
     )
     def test_time_formatter(self, time, format_expected):
         # issue 18478
-        result = self.tc(time)
+        result = converter.TimeFormatter(None)(time)
         assert result == format_expected
 
     @pytest.mark.parametrize("freq", ("B", "L", "S"))
-    def test_dateindex_conversion(self, freq):
+    def test_dateindex_conversion(self, freq, dtc):
         rtol = 10**-9
         dateindex = tm.makeDateIndex(k=10, freq=freq)
-        rs = self.dtc.convert(dateindex, None, None)
+        rs = dtc.convert(dateindex, None, None)
         xp = converter.dates.date2num(dateindex._mpl_repr())
         tm.assert_almost_equal(rs, xp, rtol=rtol)
 
     @pytest.mark.parametrize("offset", [Second(), Milli(), Micro(50)])
-    def test_resolution(self, offset):
+    def test_resolution(self, offset, dtc):
         # Matplotlib's time representation using floats cannot distinguish
         # intervals smaller than ~10 microsecond in the common range of years.
         ts1 = Timestamp("2012-1-1")
         ts2 = ts1 + offset
-        val1 = self.dtc.convert(ts1, None, None)
-        val2 = self.dtc.convert(ts2, None, None)
+        val1 = dtc.convert(ts1, None, None)
+        val2 = dtc.convert(ts2, None, None)
         if not val1 < val2:
             raise AssertionError(f"{val1} is not less than {val2}.")
 
-    def test_convert_nested(self):
+    def test_convert_nested(self, dtc):
         inner = [Timestamp("2017-01-01"), Timestamp("2017-01-02")]
         data = [inner, inner]
-        result = self.dtc.convert(data, None, None)
-        expected = [self.dtc.convert(x, None, None) for x in data]
+        result = dtc.convert(data, None, None)
+        expected = [dtc.convert(x, None, None) for x in data]
         assert (np.array(result) == expected).all()
 
 
diff --git a/pandas/tests/reshape/merge/test_join.py b/pandas/tests/reshape/merge/test_join.py
index 629c8d53ce9bd..5d6df078ee8c3 100644
--- a/pandas/tests/reshape/merge/test_join.py
+++ b/pandas/tests/reshape/merge/test_join.py
@@ -19,8 +19,6 @@
     get_test_data,
 )
 
-a_ = np.array
-
 
 class TestJoin:
     def setup_method(self):
diff --git a/pandas/tests/reshape/merge/test_merge_ordered.py b/pandas/tests/reshape/merge/test_merge_ordered.py
index cdff4737a3078..1d0d4e3eb554b 100644
--- a/pandas/tests/reshape/merge/test_merge_ordered.py
+++ b/pandas/tests/reshape/merge/test_merge_ordered.py
@@ -9,14 +9,19 @@
 import pandas._testing as tm
 
 
-class TestMergeOrdered:
-    def setup_method(self):
-        self.left = DataFrame({"key": ["a", "c", "e"], "lvalue": [1, 2.0, 3]})
+@pytest.fixture
+def left():
+    return DataFrame({"key": ["a", "c", "e"], "lvalue": [1, 2.0, 3]})
+
 
-        self.right = DataFrame({"key": ["b", "c", "d", "f"], "rvalue": [1, 2, 3.0, 4]})
+@pytest.fixture
+def right():
+    return DataFrame({"key": ["b", "c", "d", "f"], "rvalue": [1, 2, 3.0, 4]})
 
-    def test_basic(self):
-        result = merge_ordered(self.left, self.right, on="key")
+
+class TestMergeOrdered:
+    def test_basic(self, left, right):
+        result = merge_ordered(left, right, on="key")
         expected = DataFrame(
             {
                 "key": ["a", "b", "c", "d", "e", "f"],
@@ -27,8 +32,8 @@ def test_basic(self):
 
         tm.assert_frame_equal(result, expected)
 
-    def test_ffill(self):
-        result = merge_ordered(self.left, self.right, on="key", fill_method="ffill")
+    def test_ffill(self, left, right):
+        result = merge_ordered(left, right, on="key", fill_method="ffill")
         expected = DataFrame(
             {
                 "key": ["a", "b", "c", "d", "e", "f"],
@@ -38,13 +43,13 @@ def test_ffill(self):
         )
         tm.assert_frame_equal(result, expected)
 
-    def test_multigroup(self):
-        left = pd.concat([self.left, self.left], ignore_index=True)
+    def test_multigroup(self, left, right):
+        left = pd.concat([left, left], ignore_index=True)
 
         left["group"] = ["a"] * 3 + ["b"] * 3
 
         result = merge_ordered(
-            left, self.right, on="key", left_by="group", fill_method="ffill"
+            left, right, on="key", left_by="group", fill_method="ffill"
         )
         expected = DataFrame(
             {
@@ -58,21 +63,21 @@ def test_multigroup(self):
         tm.assert_frame_equal(result, expected.loc[:, result.columns])
 
         result2 = merge_ordered(
-            self.right, left, on="key", right_by="group", fill_method="ffill"
+            right, left, on="key", right_by="group", fill_method="ffill"
         )
         tm.assert_frame_equal(result, result2.loc[:, result.columns])
 
-        result = merge_ordered(left, self.right, on="key", left_by="group")
+        result = merge_ordered(left, right, on="key", left_by="group")
         assert result["group"].notna().all()
 
-    def test_merge_type(self):
+    def test_merge_type(self, left, right):
         class NotADataFrame(DataFrame):
             @property
             def _constructor(self):
                 return NotADataFrame
 
-        nad = NotADataFrame(self.left)
-        result = nad.merge(self.right, on="key")
+        nad = NotADataFrame(left)
+        result = nad.merge(right, on="key")
 
         assert isinstance(result, NotADataFrame)
 
diff --git a/pandas/tests/reshape/test_crosstab.py b/pandas/tests/reshape/test_crosstab.py
index 65b126c0fd98f..76448d5942a5a 100644
--- a/pandas/tests/reshape/test_crosstab.py
+++ b/pandas/tests/reshape/test_crosstab.py
@@ -15,66 +15,65 @@
 import pandas._testing as tm
 
 
-class TestCrosstab:
-    def setup_method(self):
-        df = DataFrame(
-            {
-                "A": [
-                    "foo",
-                    "foo",
-                    "foo",
-                    "foo",
-                    "bar",
-                    "bar",
-                    "bar",
-                    "bar",
-                    "foo",
-                    "foo",
-                    "foo",
-                ],
-                "B": [
-                    "one",
-                    "one",
-                    "one",
-                    "two",
-                    "one",
-                    "one",
-                    "one",
-                    "two",
-                    "two",
-                    "two",
-                    "one",
-                ],
-                "C": [
-                    "dull",
-                    "dull",
-                    "shiny",
-                    "dull",
-                    "dull",
-                    "shiny",
-                    "shiny",
-                    "dull",
-                    "shiny",
-                    "shiny",
-                    "shiny",
-                ],
-                "D": np.random.randn(11),
-                "E": np.random.randn(11),
-                "F": np.random.randn(11),
-            }
-        )
+@pytest.fixture
+def df():
+    df = DataFrame(
+        {
+            "A": [
+                "foo",
+                "foo",
+                "foo",
+                "foo",
+                "bar",
+                "bar",
+                "bar",
+                "bar",
+                "foo",
+                "foo",
+                "foo",
+            ],
+            "B": [
+                "one",
+                "one",
+                "one",
+                "two",
+                "one",
+                "one",
+                "one",
+                "two",
+                "two",
+                "two",
+                "one",
+            ],
+            "C": [
+                "dull",
+                "dull",
+                "shiny",
+                "dull",
+                "dull",
+                "shiny",
+                "shiny",
+                "dull",
+                "shiny",
+                "shiny",
+                "shiny",
+            ],
+            "D": np.random.randn(11),
+            "E": np.random.randn(11),
+            "F": np.random.randn(11),
+        }
+    )
 
-        self.df = pd.concat([df, df], ignore_index=True)
+    return pd.concat([df, df], ignore_index=True)
 
-    def test_crosstab_single(self):
-        df = self.df
+
+class TestCrosstab:
+    def test_crosstab_single(self, df):
         result = crosstab(df["A"], df["C"])
         expected = df.groupby(["A", "C"]).size().unstack()
         tm.assert_frame_equal(result, expected.fillna(0).astype(np.int64))
 
-    def test_crosstab_multiple(self):
-        df = self.df
-
+    def test_crosstab_multiple(self, df):
         result = crosstab(df["A"], [df["B"], df["C"]])
         expected = df.groupby(["A", "B", "C"]).size()
         expected = expected.unstack("B").unstack("C").fillna(0).astype(np.int64)
diff --git a/pandas/tests/reshape/test_melt.py b/pandas/tests/reshape/test_melt.py
index cbe33642786da..4fbfee6f829ba 100644
--- a/pandas/tests/reshape/test_melt.py
+++ b/pandas/tests/reshape/test_melt.py
@@ -11,97 +11,111 @@
 import pandas._testing as tm
 
 
-class TestMelt:
-    def setup_method(self):
-        self.df = tm.makeTimeDataFrame()[:10]
-        self.df["id1"] = (self.df["A"] > 0).astype(np.int64)
-        self.df["id2"] = (self.df["B"] > 0).astype(np.int64)
-
-        self.var_name = "var"
-        self.value_name = "val"
-
-        self.df1 = DataFrame(
-            [
-                [1.067683, -1.110463, 0.20867],
-                [-1.321405, 0.368915, -1.055342],
-                [-0.807333, 0.08298, -0.873361],
-            ]
-        )
-        self.df1.columns = [list("ABC"), list("abc")]
-        self.df1.columns.names = ["CAP", "low"]
+@pytest.fixture
+def df():
+    res = tm.makeTimeDataFrame()[:10]
+    res["id1"] = (res["A"] > 0).astype(np.int64)
+    res["id2"] = (res["B"] > 0).astype(np.int64)
+    return res
+
+
+@pytest.fixture
+def df1():
+    res = DataFrame(
+        [
+            [1.067683, -1.110463, 0.20867],
+            [-1.321405, 0.368915, -1.055342],
+            [-0.807333, 0.08298, -0.873361],
+        ]
+    )
+    res.columns = [list("ABC"), list("abc")]
+    res.columns.names = ["CAP", "low"]
+    return res
+
 
-    def test_top_level_method(self):
-        result = melt(self.df)
+@pytest.fixture
+def var_name():
+    return "var"
+
+
+@pytest.fixture
+def value_name():
+    return "val"
+
+
+class TestMelt:
+    def test_top_level_method(self, df):
+        result = melt(df)
         assert result.columns.tolist() == ["variable", "value"]
 
-    def test_method_signatures(self):
-        tm.assert_frame_equal(self.df.melt(), melt(self.df))
+    def test_method_signatures(self, df, df1, var_name, value_name):
+        tm.assert_frame_equal(df.melt(), melt(df))
 
         tm.assert_frame_equal(
-            self.df.melt(id_vars=["id1", "id2"], value_vars=["A", "B"]),
-            melt(self.df, id_vars=["id1", "id2"], value_vars=["A", "B"]),
+            df.melt(id_vars=["id1", "id2"], value_vars=["A", "B"]),
+            melt(df, id_vars=["id1", "id2"], value_vars=["A", "B"]),
         )
 
         tm.assert_frame_equal(
-            self.df.melt(var_name=self.var_name, value_name=self.value_name),
-            melt(self.df, var_name=self.var_name, value_name=self.value_name),
+            df.melt(var_name=var_name, value_name=value_name),
+            melt(df, var_name=var_name, value_name=value_name),
         )
 
-        tm.assert_frame_equal(self.df1.melt(col_level=0), melt(self.df1, col_level=0))
+        tm.assert_frame_equal(df1.melt(col_level=0), melt(df1, col_level=0))
 
-    def test_default_col_names(self):
-        result = self.df.melt()
+    def test_default_col_names(self, df):
+        result = df.melt()
         assert result.columns.tolist() == ["variable", "value"]
 
-        result1 = self.df.melt(id_vars=["id1"])
+        result1 = df.melt(id_vars=["id1"])
         assert result1.columns.tolist() == ["id1", "variable", "value"]
 
-        result2 = self.df.melt(id_vars=["id1", "id2"])
+        result2 = df.melt(id_vars=["id1", "id2"])
         assert result2.columns.tolist() == ["id1", "id2", "variable", "value"]
 
-    def test_value_vars(self):
-        result3 = self.df.melt(id_vars=["id1", "id2"], value_vars="A")
+    def test_value_vars(self, df):
+        result3 = df.melt(id_vars=["id1", "id2"], value_vars="A")
         assert len(result3) == 10
 
-        result4 = self.df.melt(id_vars=["id1", "id2"], value_vars=["A", "B"])
+        result4 = df.melt(id_vars=["id1", "id2"], value_vars=["A", "B"])
         expected4 = DataFrame(
             {
-                "id1": self.df["id1"].tolist() * 2,
-                "id2": self.df["id2"].tolist() * 2,
+                "id1": df["id1"].tolist() * 2,
+                "id2": df["id2"].tolist() * 2,
                 "variable": ["A"] * 10 + ["B"] * 10,
-                "value": (self.df["A"].tolist() + self.df["B"].tolist()),
+                "value": (df["A"].tolist() + df["B"].tolist()),
             },
             columns=["id1", "id2", "variable", "value"],
         )
         tm.assert_frame_equal(result4, expected4)
 
     @pytest.mark.parametrize("type_", (tuple, list, np.array))
-    def test_value_vars_types(self, type_):
+    def test_value_vars_types(self, type_, df):
         # GH 15348
         expected = DataFrame(
             {
-                "id1": self.df["id1"].tolist() * 2,
-                "id2": self.df["id2"].tolist() * 2,
+                "id1": df["id1"].tolist() * 2,
+                "id2": df["id2"].tolist() * 2,
                 "variable": ["A"] * 10 + ["B"] * 10,
-                "value": (self.df["A"].tolist() + self.df["B"].tolist()),
+                "value": (df["A"].tolist() + df["B"].tolist()),
             },
             columns=["id1", "id2", "variable", "value"],
         )
-        result = self.df.melt(id_vars=["id1", "id2"], value_vars=type_(("A", "B")))
+        result = df.melt(id_vars=["id1", "id2"], value_vars=type_(("A", "B")))
         tm.assert_frame_equal(result, expected)
 
-    def test_vars_work_with_multiindex(self):
+    def test_vars_work_with_multiindex(self, df1):
         expected = DataFrame(
             {
-                ("A", "a"): self.df1[("A", "a")],
-                "CAP": ["B"] * len(self.df1),
-                "low": ["b"] * len(self.df1),
-                "value": self.df1[("B", "b")],
+                ("A", "a"): df1[("A", "a")],
+                "CAP": ["B"] * len(df1),
+                "low": ["b"] * len(df1),
+                "value": df1[("B", "b")],
             },
             columns=[("A", "a"), "CAP", "low", "value"],
         )
 
-        result = self.df1.melt(id_vars=[("A", "a")], value_vars=[("B", "b")])
+        result = df1.melt(id_vars=[("A", "a")], value_vars=[("B", "b")])
         tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize(
@@ -134,9 +148,9 @@ def test_vars_work_with_multiindex(self):
         ],
     )
     def test_single_vars_work_with_multiindex(
-        self, id_vars, value_vars, col_level, expected
+        self, id_vars, value_vars, col_level, expected, df1
     ):
-        result = self.df1.melt(id_vars, value_vars, col_level=col_level)
+        result = df1.melt(id_vars, value_vars, col_level=col_level)
         tm.assert_frame_equal(result, expected)
 
     @pytest.mark.parametrize(
@@ -147,124 +161,120 @@ def test_single_vars_work_with_multiindex(
             [("A", "a"), ("B", "b")],
         ],
     )
-    def test_tuple_vars_fail_with_multiindex(self, id_vars, value_vars):
+    def test_tuple_vars_fail_with_multiindex(self, id_vars, value_vars, df1):
         # melt should fail with an informative error message if
         # the columns have a MultiIndex and a tuple is passed
         # for id_vars or value_vars.
         msg = r"(id|value)_vars must be a list of tuples when columns are a MultiIndex"
         with pytest.raises(ValueError, match=msg):
-            self.df1.melt(id_vars=id_vars, value_vars=value_vars)
+            df1.melt(id_vars=id_vars, value_vars=value_vars)
 
-    def test_custom_var_name(self):
-        result5 = self.df.melt(var_name=self.var_name)
+    def test_custom_var_name(self, df, var_name):
+        result5 = df.melt(var_name=var_name)
         assert result5.columns.tolist() == ["var", "value"]
 
-        result6 = self.df.melt(id_vars=["id1"], var_name=self.var_name)
+        result6 = df.melt(id_vars=["id1"], var_name=var_name)
         assert result6.columns.tolist() == ["id1", "var", "value"]
 
-        result7 = self.df.melt(id_vars=["id1", "id2"], var_name=self.var_name)
+        result7 = df.melt(id_vars=["id1", "id2"], var_name=var_name)
         assert result7.columns.tolist() == ["id1", "id2", "var", "value"]
 
-        result8 = self.df.melt(
-            id_vars=["id1", "id2"], value_vars="A", var_name=self.var_name
-        )
+        result8 = df.melt(id_vars=["id1", "id2"], value_vars="A", var_name=var_name)
         assert result8.columns.tolist() == ["id1", "id2", "var", "value"]
 
-        result9 = self.df.melt(
-            id_vars=["id1", "id2"], value_vars=["A", "B"], var_name=self.var_name
+        result9 = df.melt(
+            id_vars=["id1", "id2"], value_vars=["A", "B"], var_name=var_name
         )
         expected9 = DataFrame(
             {
-                "id1": self.df["id1"].tolist() * 2,
-                "id2": self.df["id2"].tolist() * 2,
-                self.var_name: ["A"] * 10 + ["B"] * 10,
-                "value": (self.df["A"].tolist() + self.df["B"].tolist()),
+                "id1": df["id1"].tolist() * 2,
+                "id2": df["id2"].tolist() * 2,
+                var_name: ["A"] * 10 + ["B"] * 10,
+                "value": (df["A"].tolist() + df["B"].tolist()),
             },
-            columns=["id1", "id2", self.var_name, "value"],
+            columns=["id1", "id2", var_name, "value"],
         )
         tm.assert_frame_equal(result9, expected9)
 
-    def test_custom_value_name(self):
-        result10 = self.df.melt(value_name=self.value_name)
+    def test_custom_value_name(self, df, value_name):
+        result10 = df.melt(value_name=value_name)
         assert result10.columns.tolist() == ["variable", "val"]
 
-        result11 = self.df.melt(id_vars=["id1"], value_name=self.value_name)
+        result11 = df.melt(id_vars=["id1"], value_name=value_name)
         assert result11.columns.tolist() == ["id1", "variable", "val"]
 
-        result12 = self.df.melt(id_vars=["id1", "id2"], value_name=self.value_name)
+        result12 = df.melt(id_vars=["id1", "id2"], value_name=value_name)
         assert result12.columns.tolist() == ["id1", "id2", "variable", "val"]
 
-        result13 = self.df.melt(
-            id_vars=["id1", "id2"], value_vars="A", value_name=self.value_name
+        result13 = df.melt(
+            id_vars=["id1", "id2"], value_vars="A", value_name=value_name
         )
         assert result13.columns.tolist() == ["id1", "id2", "variable", "val"]
 
-        result14 = self.df.melt(
-            id_vars=["id1", "id2"], value_vars=["A", "B"], value_name=self.value_name
+        result14 = df.melt(
+            id_vars=["id1", "id2"], value_vars=["A", "B"], value_name=value_name
         )
         expected14 = DataFrame(
             {
-                "id1": self.df["id1"].tolist() * 2,
-                "id2": self.df["id2"].tolist() * 2,
+                "id1": df["id1"].tolist() * 2,
+                "id2": df["id2"].tolist() * 2,
                 "variable": ["A"] * 10 + ["B"] * 10,
-                self.value_name: (self.df["A"].tolist() + self.df["B"].tolist()),
+                value_name: (df["A"].tolist() + df["B"].tolist()),
             },
-            columns=["id1", "id2", "variable", self.value_name],
+            columns=["id1", "id2", "variable", value_name],
         )
         tm.assert_frame_equal(result14, expected14)
 
-    def test_custom_var_and_value_name(self):
+    def test_custom_var_and_value_name(self, df, value_name, var_name):
 
-        result15 = self.df.melt(var_name=self.var_name, value_name=self.value_name)
+        result15 = df.melt(var_name=var_name, value_name=value_name)
         assert result15.columns.tolist() == ["var", "val"]
 
-        result16 = self.df.melt(
-            id_vars=["id1"], var_name=self.var_name, value_name=self.value_name
-        )
+        result16 = df.melt(id_vars=["id1"], var_name=var_name, value_name=value_name)
         assert result16.columns.tolist() == ["id1", "var", "val"]
 
-        result17 = self.df.melt(
-            id_vars=["id1", "id2"], var_name=self.var_name, value_name=self.value_name
+        result17 = df.melt(
+            id_vars=["id1", "id2"], var_name=var_name, value_name=value_name
         )
         assert result17.columns.tolist() == ["id1", "id2", "var", "val"]
 
-        result18 = self.df.melt(
+        result18 = df.melt(
             id_vars=["id1", "id2"],
             value_vars="A",
-            var_name=self.var_name,
-            value_name=self.value_name,
+            var_name=var_name,
+            value_name=value_name,
         )
         assert result18.columns.tolist() == ["id1", "id2", "var", "val"]
 
-        result19 = self.df.melt(
+        result19 = df.melt(
             id_vars=["id1", "id2"],
             value_vars=["A", "B"],
-            var_name=self.var_name,
-            value_name=self.value_name,
+            var_name=var_name,
+            value_name=value_name,
         )
         expected19 = DataFrame(
             {
-                "id1": self.df["id1"].tolist() * 2,
-                "id2": self.df["id2"].tolist() * 2,
-                self.var_name: ["A"] * 10 + ["B"] * 10,
-                self.value_name: (self.df["A"].tolist() + self.df["B"].tolist()),
+                "id1": df["id1"].tolist() * 2,
+                "id2": df["id2"].tolist() * 2,
+                var_name: ["A"] * 10 + ["B"] * 10,
+                value_name: (df["A"].tolist() + df["B"].tolist()),
             },
-            columns=["id1", "id2", self.var_name, self.value_name],
+            columns=["id1", "id2", var_name, value_name],
         )
         tm.assert_frame_equal(result19, expected19)
 
-        df20 = self.df.copy()
+        df20 = df.copy()
         df20.columns.name = "foo"
         result20 = df20.melt()
         assert result20.columns.tolist() == ["foo", "value"]
 
     @pytest.mark.parametrize("col_level", [0, "CAP"])
-    def test_col_level(self, col_level):
-        res = self.df1.melt(col_level=col_level)
+    def test_col_level(self, col_level, df1):
+        res = df1.melt(col_level=col_level)
         assert res.columns.tolist() == ["CAP", "value"]
 
-    def test_multiindex(self):
-        res = self.df1.melt()
+    def test_multiindex(self, df1):
+        res = df1.melt()
         assert res.columns.tolist() == ["CAP", "low", "value"]
 
     @pytest.mark.parametrize(