Merge branch 'ref/index_equiv' of https://github.com/mroeschke/pandas into ref/index_equiv

Author: mroeschke

pandas/tests/frame/methods/test_compare.py

@@ -21,15 +21,15 @@ def test_compare_axis(align_axis):
     result = df.compare(df2, align_axis=align_axis)
 
     if align_axis in (1, "columns"):
-        indices = pd.Index([0, 2])
+        indices = pd.RangeIndex(0, 4, 2)
         columns = pd.MultiIndex.from_product([["col1", "col3"], ["self", "other"]])
         expected = pd.DataFrame(
             [["a", "c", np.nan, np.nan], [np.nan, np.nan, 3.0, 4.0]],
             index=indices,
             columns=columns,
         )
     else:
-        indices = pd.MultiIndex.from_product([[0, 2], ["self", "other"]])
+        indices = pd.MultiIndex.from_product([range(0, 4, 2), ["self", "other"]])
         columns = pd.Index(["col1", "col3"])
         expected = pd.DataFrame(
             [["a", np.nan], ["c", np.nan], [np.nan, 3.0], [np.nan, 4.0]],
@@ -60,7 +60,7 @@ def test_compare_various_formats(keep_shape, keep_equal):
     result = df.compare(df2, keep_shape=keep_shape, keep_equal=keep_equal)
 
     if keep_shape:
-        indices = pd.Index([0, 1, 2])
+        indices = pd.RangeIndex(3)
         columns = pd.MultiIndex.from_product(
             [["col1", "col2", "col3"], ["self", "other"]]
         )
@@ -85,7 +85,7 @@ def test_compare_various_formats(keep_shape, keep_equal):
                 columns=columns,
             )
     else:
-        indices = pd.Index([0, 2])
+        indices = pd.RangeIndex(0, 4, 2)
         columns = pd.MultiIndex.from_product([["col1", "col3"], ["self", "other"]])
         expected = pd.DataFrame(
             [["a", "c", 1.0, 1.0], ["c", "c", 3.0, 4.0]], index=indices, columns=columns
@@ -203,6 +203,7 @@ def test_compare_result_names():
         },
     )
     result = df1.compare(df2, result_names=("left", "right"))
+    result.index = pd.Index([0, 2])
     expected = pd.DataFrame(
         {
             ("col1", "left"): {0: "a", 2: np.nan},

pandas/tests/frame/methods/test_drop_duplicates.py

@@ -411,10 +411,15 @@ def test_drop_duplicates_inplace():
 @pytest.mark.parametrize(
     "origin_dict, output_dict, ignore_index, output_index",
     [
-        ({"A": [2, 2, 3]}, {"A": [2, 3]}, True, [0, 1]),
-        ({"A": [2, 2, 3]}, {"A": [2, 3]}, False, [0, 2]),
-        ({"A": [2, 2, 3], "B": [2, 2, 4]}, {"A": [2, 3], "B": [2, 4]}, True, [0, 1]),
-        ({"A": [2, 2, 3], "B": [2, 2, 4]}, {"A": [2, 3], "B": [2, 4]}, False, [0, 2]),
+        ({"A": [2, 2, 3]}, {"A": [2, 3]}, True, range(2)),
+        ({"A": [2, 2, 3]}, {"A": [2, 3]}, False, range(0, 4, 2)),
+        ({"A": [2, 2, 3], "B": [2, 2, 4]}, {"A": [2, 3], "B": [2, 4]}, True, range(2)),
+        (
+            {"A": [2, 2, 3], "B": [2, 2, 4]},
+            {"A": [2, 3], "B": [2, 4]},
+            False,
+            range(0, 4, 2),
+        ),
     ],
 )
 def test_drop_duplicates_ignore_index(

pandas/tests/frame/methods/test_dropna.py

@@ -195,7 +195,7 @@ def test_dropna_tz_aware_datetime(self):
         # Ex2
         df = DataFrame({"Time": [dt1, None, np.nan, dt2]})
         result = df.dropna(axis=0)
-        expected = DataFrame([dt1, dt2], columns=["Time"], index=[0, 3])
+        expected = DataFrame([dt1, dt2], columns=["Time"], index=range(0, 6, 3))
         tm.assert_frame_equal(result, expected)
 
     def test_dropna_categorical_interval_index(self):
@@ -233,7 +233,7 @@ def test_set_single_column_subset(self):
         # GH 41021
         df = DataFrame({"A": [1, 2, 3], "B": list("abc"), "C": [4, np.nan, 5]})
         expected = DataFrame(
-            {"A": [1, 3], "B": list("ac"), "C": [4.0, 5.0]}, index=[0, 2]
+            {"A": [1, 3], "B": list("ac"), "C": [4.0, 5.0]}, index=range(0, 4, 2)
         )
         result = df.dropna(subset="C")
         tm.assert_frame_equal(result, expected)

pandas/tests/frame/methods/test_explode.py

@@ -210,7 +210,7 @@ def test_ignore_index():
     df = pd.DataFrame({"id": range(0, 20, 10), "values": [list("ab"), list("cd")]})
     result = df.explode("values", ignore_index=True)
     expected = pd.DataFrame(
-        {"id": [0, 0, 10, 10], "values": list("abcd")}, index=[0, 1, 2, 3]
+        {"id": [0, 0, 10, 10], "values": list("abcd")}, index=range(4)
     )
     tm.assert_frame_equal(result, expected)
 

pandas/tests/frame/methods/test_transpose.py

@@ -25,6 +25,7 @@ def test_transpose_td64_intervals(self):
         df = DataFrame(ii)
 
         result = df.T
+        result.columns = Index(list(range(len(ii))))
         expected = DataFrame({i: ii[i : i + 1] for i in range(len(ii))})
         tm.assert_frame_equal(result, expected)
 
@@ -153,7 +154,6 @@ def test_transpose_not_inferring_dt(self):
         result = df.T
         expected = DataFrame(
             [[Timestamp("2019-12-31"), Timestamp("2019-12-31")]],
-            columns=[0, 1],
             index=["a"],
             dtype=object,
         )
@@ -175,7 +175,6 @@ def test_transpose_not_inferring_dt_mixed_blocks(self):
                 [Timestamp("2019-12-31"), Timestamp("2019-12-31")],
                 [Timestamp("2019-12-31"), Timestamp("2019-12-31")],
             ],
-            columns=[0, 1],
             index=["a", "b"],
             dtype=object,
         )

pandas/tests/groupby/test_filters.py

@@ -242,7 +242,7 @@ def test_filter_using_len():
     actual = grouped.filter(lambda x: len(x) > 2)
     expected = DataFrame(
         {"A": np.arange(2, 6), "B": list("bbbb"), "C": np.arange(2, 6)},
-        index=np.arange(2, 6, dtype=np.int64),
+        index=range(2, 6),
     )
     tm.assert_frame_equal(actual, expected)
 
@@ -254,7 +254,7 @@ def test_filter_using_len():
     s = df["B"]
     grouped = s.groupby(s)
     actual = grouped.filter(lambda x: len(x) > 2)
-    expected = Series(4 * ["b"], index=np.arange(2, 6, dtype=np.int64), name="B")
+    expected = Series(4 * ["b"], index=range(2, 6), name="B")
     tm.assert_series_equal(actual, expected)
 
     actual = grouped.filter(lambda x: len(x) > 4)

pandas/tests/indexes/numeric/test_setops.py

@@ -41,7 +41,7 @@ def test_intersection(self):
 
         other = Index([1, 2, 3, 4, 5])
         result = index.intersection(other)
-        expected = Index(np.sort(np.intersect1d(index.values, other.values)))
+        expected = Index(range(1, 5))
         tm.assert_index_equal(result, expected)
 
         result = other.intersection(index)

pandas/tests/series/methods/test_reindex.py

@@ -234,13 +234,15 @@ def test_reindex_categorical():
     tm.assert_series_equal(result, expected)
 
     # partial reindexing
-    expected = Series(Categorical(values=["b", "c"], categories=["a", "b", "c"]))
-    expected.index = [1, 2]
+    expected = Series(
+        Categorical(values=["b", "c"], categories=["a", "b", "c"]), index=range(1, 3)
+    )
     result = s.reindex([1, 2])
     tm.assert_series_equal(result, expected)
 
-    expected = Series(Categorical(values=["c", np.nan], categories=["a", "b", "c"]))
-    expected.index = [2, 3]
+    expected = Series(
+        Categorical(values=["c", np.nan], categories=["a", "b", "c"]), index=range(2, 4)
+    )
     result = s.reindex([2, 3])
     tm.assert_series_equal(result, expected)
 
@@ -261,24 +263,24 @@ def test_reindex_fill_value():
     # floats
     floats = Series([1.0, 2.0, 3.0])
     result = floats.reindex([1, 2, 3])
-    expected = Series([2.0, 3.0, np.nan], index=[1, 2, 3])
+    expected = Series([2.0, 3.0, np.nan], index=range(1, 4))
     tm.assert_series_equal(result, expected)
 
     result = floats.reindex([1, 2, 3], fill_value=0)
-    expected = Series([2.0, 3.0, 0], index=[1, 2, 3])
+    expected = Series([2.0, 3.0, 0], index=range(1, 4))
     tm.assert_series_equal(result, expected)
 
     # -----------------------------------------------------------
     # ints
     ints = Series([1, 2, 3])
 
     result = ints.reindex([1, 2, 3])
-    expected = Series([2.0, 3.0, np.nan], index=[1, 2, 3])
+    expected = Series([2.0, 3.0, np.nan], index=range(1, 4))
     tm.assert_series_equal(result, expected)
 
     # don't upcast
     result = ints.reindex([1, 2, 3], fill_value=0)
-    expected = Series([2, 3, 0], index=[1, 2, 3])
+    expected = Series([2, 3, 0], index=range(1, 4))
     assert issubclass(result.dtype.type, np.integer)
     tm.assert_series_equal(result, expected)
 
@@ -287,23 +289,23 @@ def test_reindex_fill_value():
     objects = Series([1, 2, 3], dtype=object)
 
     result = objects.reindex([1, 2, 3])
-    expected = Series([2, 3, np.nan], index=[1, 2, 3], dtype=object)
+    expected = Series([2, 3, np.nan], index=range(1, 4), dtype=object)
     tm.assert_series_equal(result, expected)
 
     result = objects.reindex([1, 2, 3], fill_value="foo")
-    expected = Series([2, 3, "foo"], index=[1, 2, 3], dtype=object)
+    expected = Series([2, 3, "foo"], index=range(1, 4), dtype=object)
     tm.assert_series_equal(result, expected)
 
     # ------------------------------------------------------------
     # bools
     bools = Series([True, False, True])
 
     result = bools.reindex([1, 2, 3])
-    expected = Series([False, True, np.nan], index=[1, 2, 3], dtype=object)
+    expected = Series([False, True, np.nan], index=range(1, 4), dtype=object)
     tm.assert_series_equal(result, expected)
 
     result = bools.reindex([1, 2, 3], fill_value=False)
-    expected = Series([False, True, False], index=[1, 2, 3])
+    expected = Series([False, True, False], index=range(1, 4))
     tm.assert_series_equal(result, expected)
 
 
@@ -318,7 +320,7 @@ def test_reindex_fill_value_datetimelike_upcast(dtype, fill_value):
     ser = Series([NaT], dtype=dtype)
 
     result = ser.reindex([0, 1], fill_value=fill_value)
-    expected = Series([NaT, fill_value], index=[0, 1], dtype=object)
+    expected = Series([NaT, fill_value], index=range(2), dtype=object)
     tm.assert_series_equal(result, expected)
 
 

pandas/tests/test_sorting.py

@@ -221,7 +221,6 @@ def test_int64_overflow_how_merge(self, left_right, join_type):
 
         out = merge(left, right, how="outer")
         out.sort_values(out.columns.tolist(), inplace=True)
-        out.index = np.arange(len(out))
         tm.assert_frame_equal(out, merge(left, right, how=join_type, sort=True))
 
     @pytest.mark.slow