From f4b67b5eafca7310235cb4b037978739d0e3e52e Mon Sep 17 00:00:00 2001 From: Alexandre Prince-Levasseur <46272939+alexprincel@users.noreply.github.com> Date: Sun, 28 Feb 2021 08:41:21 -0500 Subject: [PATCH] STYLE: Inconsistent namespace - reshape (#39992) (#40058) Co-authored-by: Marco Gorelli --- pandas/tests/reshape/concat/test_concat.py | 32 ++-- pandas/tests/reshape/concat/test_dataframe.py | 38 +++-- pandas/tests/reshape/concat/test_datetimes.py | 60 ++++--- pandas/tests/reshape/concat/test_empty.py | 32 ++-- pandas/tests/reshape/concat/test_index.py | 14 +- pandas/tests/reshape/concat/test_series.py | 7 +- pandas/tests/reshape/merge/test_join.py | 8 +- pandas/tests/reshape/merge/test_merge.py | 110 +++++++------ pandas/tests/reshape/merge/test_merge_asof.py | 150 +++++++++--------- pandas/tests/reshape/merge/test_multi.py | 14 +- pandas/tests/reshape/test_cut.py | 4 +- pandas/tests/reshape/test_melt.py | 10 +- pandas/tests/reshape/test_pivot.py | 26 +-- 13 files changed, 245 insertions(+), 260 deletions(-) diff --git a/pandas/tests/reshape/concat/test_concat.py b/pandas/tests/reshape/concat/test_concat.py index 47d9bddcf50ad..7b520171379c3 100644 --- a/pandas/tests/reshape/concat/test_concat.py +++ b/pandas/tests/reshape/concat/test_concat.py @@ -437,21 +437,21 @@ def __getitem__(self, index): except KeyError as err: raise IndexError from err - tm.assert_frame_equal(pd.concat(CustomIterator1(), ignore_index=True), expected) + tm.assert_frame_equal(concat(CustomIterator1(), ignore_index=True), expected) class CustomIterator2(abc.Iterable): def __iter__(self): yield df1 yield df2 - tm.assert_frame_equal(pd.concat(CustomIterator2(), ignore_index=True), expected) + tm.assert_frame_equal(concat(CustomIterator2(), ignore_index=True), expected) def test_concat_order(self): # GH 17344 dfs = [DataFrame(index=range(3), columns=["a", 1, None])] dfs += [DataFrame(index=range(3), columns=[None, 1, "a"]) for i in range(100)] - result = pd.concat(dfs, sort=True).columns + result = concat(dfs, sort=True).columns expected = dfs[0].columns tm.assert_index_equal(result, expected) @@ -459,20 +459,20 @@ def test_concat_different_extension_dtypes_upcasts(self): a = Series(pd.array([1, 2], dtype="Int64")) b = Series(to_decimal([1, 2])) - result = pd.concat([a, b], ignore_index=True) + result = concat([a, b], ignore_index=True) expected = Series([1, 2, Decimal(1), Decimal(2)], dtype=object) tm.assert_series_equal(result, expected) def test_concat_ordered_dict(self): # GH 21510 - expected = pd.concat( + expected = concat( [Series(range(3)), Series(range(4))], keys=["First", "Another"] ) - result = pd.concat({"First": Series(range(3)), "Another": Series(range(4))}) + result = concat({"First": Series(range(3)), "Another": Series(range(4))}) tm.assert_series_equal(result, expected) -@pytest.mark.parametrize("pdt", [Series, pd.DataFrame]) +@pytest.mark.parametrize("pdt", [Series, DataFrame]) @pytest.mark.parametrize("dt", np.sctypes["float"]) def test_concat_no_unnecessary_upcast(dt, pdt): # GH 13247 @@ -483,11 +483,11 @@ def test_concat_no_unnecessary_upcast(dt, pdt): pdt(np.array([np.nan], dtype=dt, ndmin=dims)), pdt(np.array([5], dtype=dt, ndmin=dims)), ] - x = pd.concat(dfs) + x = concat(dfs) assert x.values.dtype == dt -@pytest.mark.parametrize("pdt", [create_series_with_explicit_dtype, pd.DataFrame]) +@pytest.mark.parametrize("pdt", [create_series_with_explicit_dtype, DataFrame]) @pytest.mark.parametrize("dt", np.sctypes["int"]) def test_concat_will_upcast(dt, pdt): with catch_warnings(record=True): @@ -497,7 +497,7 @@ def test_concat_will_upcast(dt, pdt): pdt(np.array([np.nan], ndmin=dims)), pdt(np.array([5], dtype=dt, ndmin=dims)), ] - x = pd.concat(dfs) + x = concat(dfs) assert x.values.dtype == "float64" @@ -506,7 +506,7 @@ def test_concat_empty_and_non_empty_frame_regression(): df1 = DataFrame({"foo": [1]}) df2 = DataFrame({"foo": []}) expected = DataFrame({"foo": [1.0]}) - result = pd.concat([df1, df2]) + result = concat([df1, df2]) tm.assert_frame_equal(result, expected) @@ -516,7 +516,7 @@ def test_concat_sparse(): expected = DataFrame(data=[[0, 0], [1, 1], [2, 2]]).astype( pd.SparseDtype(np.int64, 0) ) - result = pd.concat([a, a], axis=1) + result = concat([a, a], axis=1) tm.assert_frame_equal(result, expected) @@ -527,7 +527,7 @@ def test_concat_dense_sparse(): expected = Series(data=[1, None, 1], index=[0, 1, 0]).astype( pd.SparseDtype(np.float64, None) ) - result = pd.concat([a, b], axis=0) + result = concat([a, b], axis=0) tm.assert_series_equal(result, expected) @@ -565,11 +565,11 @@ def test_concat_frame_axis0_extension_dtypes(): df1 = DataFrame({"a": pd.array([1, 2, 3], dtype="Int64")}) df2 = DataFrame({"a": np.array([4, 5, 6])}) - result = pd.concat([df1, df2], ignore_index=True) + result = concat([df1, df2], ignore_index=True) expected = DataFrame({"a": [1, 2, 3, 4, 5, 6]}, dtype="Int64") tm.assert_frame_equal(result, expected) - result = pd.concat([df2, df1], ignore_index=True) + result = concat([df2, df1], ignore_index=True) expected = DataFrame({"a": [4, 5, 6, 1, 2, 3]}, dtype="Int64") tm.assert_frame_equal(result, expected) @@ -578,7 +578,7 @@ def test_concat_preserves_extension_int64_dtype(): # GH 24768 df_a = DataFrame({"a": [-1]}, dtype="Int64") df_b = DataFrame({"b": [1]}, dtype="Int64") - result = pd.concat([df_a, df_b], ignore_index=True) + result = concat([df_a, df_b], ignore_index=True) expected = DataFrame({"a": [-1, None], "b": [None, 1]}, dtype="Int64") tm.assert_frame_equal(result, expected) diff --git a/pandas/tests/reshape/concat/test_dataframe.py b/pandas/tests/reshape/concat/test_dataframe.py index f5eb0ab8c9a17..3636139c19eef 100644 --- a/pandas/tests/reshape/concat/test_dataframe.py +++ b/pandas/tests/reshape/concat/test_dataframe.py @@ -17,7 +17,7 @@ def test_concat_multiple_frames_dtypes(self): # GH#2759 A = DataFrame(data=np.ones((10, 2)), columns=["foo", "bar"], dtype=np.float64) B = DataFrame(data=np.ones((10, 2)), dtype=np.float32) - results = pd.concat((A, B), axis=1).dtypes + results = concat((A, B), axis=1).dtypes expected = Series( [np.dtype("float64")] * 2 + [np.dtype("float32")] * 2, index=["foo", "bar", 0, 1], @@ -28,7 +28,7 @@ def test_concat_tuple_keys(self): # GH#14438 df1 = DataFrame(np.ones((2, 2)), columns=list("AB")) df2 = DataFrame(np.ones((3, 2)) * 2, columns=list("AB")) - results = pd.concat((df1, df2), keys=[("bee", "bah"), ("bee", "boo")]) + results = concat((df1, df2), keys=[("bee", "bah"), ("bee", "boo")]) expected = DataFrame( { "A": { @@ -53,7 +53,7 @@ def test_concat_named_keys(self): # GH#14252 df = DataFrame({"foo": [1, 2], "bar": [0.1, 0.2]}) index = Index(["a", "b"], name="baz") - concatted_named_from_keys = pd.concat([df, df], keys=index) + concatted_named_from_keys = concat([df, df], keys=index) expected_named = DataFrame( {"foo": [1, 2, 1, 2], "bar": [0.1, 0.2, 0.1, 0.2]}, index=pd.MultiIndex.from_product((["a", "b"], [0, 1]), names=["baz", None]), @@ -61,12 +61,10 @@ def test_concat_named_keys(self): tm.assert_frame_equal(concatted_named_from_keys, expected_named) index_no_name = Index(["a", "b"], name=None) - concatted_named_from_names = pd.concat( - [df, df], keys=index_no_name, names=["baz"] - ) + concatted_named_from_names = concat([df, df], keys=index_no_name, names=["baz"]) tm.assert_frame_equal(concatted_named_from_names, expected_named) - concatted_unnamed = pd.concat([df, df], keys=index_no_name) + concatted_unnamed = concat([df, df], keys=index_no_name) expected_unnamed = DataFrame( {"foo": [1, 2, 1, 2], "bar": [0.1, 0.2, 0.1, 0.2]}, index=pd.MultiIndex.from_product((["a", "b"], [0, 1]), names=[None, None]), @@ -81,13 +79,13 @@ def test_concat_axis_parameter(self): # Index/row/0 DataFrame expected_index = DataFrame({"A": [0.1, 0.2, 0.3, 0.4]}, index=[0, 1, 0, 1]) - concatted_index = pd.concat([df1, df2], axis="index") + concatted_index = concat([df1, df2], axis="index") tm.assert_frame_equal(concatted_index, expected_index) - concatted_row = pd.concat([df1, df2], axis="rows") + concatted_row = concat([df1, df2], axis="rows") tm.assert_frame_equal(concatted_row, expected_index) - concatted_0 = pd.concat([df1, df2], axis=0) + concatted_0 = concat([df1, df2], axis=0) tm.assert_frame_equal(concatted_0, expected_index) # Columns/1 DataFrame @@ -95,10 +93,10 @@ def test_concat_axis_parameter(self): [[0.1, 0.3], [0.2, 0.4]], index=[0, 1], columns=["A", "A"] ) - concatted_columns = pd.concat([df1, df2], axis="columns") + concatted_columns = concat([df1, df2], axis="columns") tm.assert_frame_equal(concatted_columns, expected_columns) - concatted_1 = pd.concat([df1, df2], axis=1) + concatted_1 = concat([df1, df2], axis=1) tm.assert_frame_equal(concatted_1, expected_columns) series1 = Series([0.1, 0.2]) @@ -107,13 +105,13 @@ def test_concat_axis_parameter(self): # Index/row/0 Series expected_index_series = Series([0.1, 0.2, 0.3, 0.4], index=[0, 1, 0, 1]) - concatted_index_series = pd.concat([series1, series2], axis="index") + concatted_index_series = concat([series1, series2], axis="index") tm.assert_series_equal(concatted_index_series, expected_index_series) - concatted_row_series = pd.concat([series1, series2], axis="rows") + concatted_row_series = concat([series1, series2], axis="rows") tm.assert_series_equal(concatted_row_series, expected_index_series) - concatted_0_series = pd.concat([series1, series2], axis=0) + concatted_0_series = concat([series1, series2], axis=0) tm.assert_series_equal(concatted_0_series, expected_index_series) # Columns/1 Series @@ -121,15 +119,15 @@ def test_concat_axis_parameter(self): [[0.1, 0.3], [0.2, 0.4]], index=[0, 1], columns=[0, 1] ) - concatted_columns_series = pd.concat([series1, series2], axis="columns") + concatted_columns_series = concat([series1, series2], axis="columns") tm.assert_frame_equal(concatted_columns_series, expected_columns_series) - concatted_1_series = pd.concat([series1, series2], axis=1) + concatted_1_series = concat([series1, series2], axis=1) tm.assert_frame_equal(concatted_1_series, expected_columns_series) # Testing ValueError with pytest.raises(ValueError, match="No axis named"): - pd.concat([series1, series2], axis="something") + concat([series1, series2], axis="something") def test_concat_numerical_names(self): # GH#15262, GH#12223 @@ -142,7 +140,7 @@ def test_concat_numerical_names(self): ) ), ) - result = pd.concat((df.iloc[:2, :], df.iloc[-2:, :])) + result = concat((df.iloc[:2, :], df.iloc[-2:, :])) expected = DataFrame( {"col": [0, 1, 7, 8]}, dtype="int32", @@ -155,7 +153,7 @@ def test_concat_numerical_names(self): def test_concat_astype_dup_col(self): # GH#23049 df = DataFrame([{"a": "b"}]) - df = pd.concat([df, df], axis=1) + df = concat([df, df], axis=1) result = df.astype("category") expected = DataFrame( diff --git a/pandas/tests/reshape/concat/test_datetimes.py b/pandas/tests/reshape/concat/test_datetimes.py index 92181e7dffc50..332c3c8f30562 100644 --- a/pandas/tests/reshape/concat/test_datetimes.py +++ b/pandas/tests/reshape/concat/test_datetimes.py @@ -44,15 +44,15 @@ def test_concat_datetime_datetime64_frame(self): df1 = DataFrame({"date": ind, "test": range(10)}) # it works! - pd.concat([df1, df2_obj]) + concat([df1, df2_obj]) def test_concat_datetime_timezone(self): # GH 18523 - idx1 = pd.date_range("2011-01-01", periods=3, freq="H", tz="Europe/Paris") - idx2 = pd.date_range(start=idx1[0], end=idx1[-1], freq="H") + idx1 = date_range("2011-01-01", periods=3, freq="H", tz="Europe/Paris") + idx2 = date_range(start=idx1[0], end=idx1[-1], freq="H") df1 = DataFrame({"a": [1, 2, 3]}, index=idx1) df2 = DataFrame({"b": [1, 2, 3]}, index=idx2) - result = pd.concat([df1, df2], axis=1) + result = concat([df1, df2], axis=1) exp_idx = ( DatetimeIndex( @@ -73,9 +73,9 @@ def test_concat_datetime_timezone(self): tm.assert_frame_equal(result, expected) - idx3 = pd.date_range("2011-01-01", periods=3, freq="H", tz="Asia/Tokyo") + idx3 = date_range("2011-01-01", periods=3, freq="H", tz="Asia/Tokyo") df3 = DataFrame({"b": [1, 2, 3]}, index=idx3) - result = pd.concat([df1, df3], axis=1) + result = concat([df1, df3], axis=1) exp_idx = DatetimeIndex( [ @@ -104,9 +104,7 @@ def test_concat_datetime_timezone(self): tm.assert_frame_equal(result, expected) # GH 13783: Concat after resample - result = pd.concat( - [df1.resample("H").mean(), df2.resample("H").mean()], sort=True - ) + result = concat([df1.resample("H").mean(), df2.resample("H").mean()], sort=True) expected = DataFrame( {"a": [1, 2, 3] + [np.nan] * 3, "b": [np.nan] * 3 + [1, 2, 3]}, index=idx1.append(idx1), @@ -116,14 +114,14 @@ def test_concat_datetime_timezone(self): def test_concat_datetimeindex_freq(self): # GH 3232 # Monotonic index result - dr = pd.date_range("01-Jan-2013", periods=100, freq="50L", tz="UTC") + dr = date_range("01-Jan-2013", periods=100, freq="50L", tz="UTC") data = list(range(100)) expected = DataFrame(data, index=dr) - result = pd.concat([expected[:50], expected[50:]]) + result = concat([expected[:50], expected[50:]]) tm.assert_frame_equal(result, expected) # Non-monotonic index result - result = pd.concat([expected[50:], expected[:50]]) + result = concat([expected[50:], expected[:50]]) expected = DataFrame(data[50:] + data[:50], index=dr[50:].append(dr[:50])) expected.index._data.freq = None tm.assert_frame_equal(result, expected) @@ -179,21 +177,21 @@ def test_concat_NaT_series(self): # all NaT with tz expected = Series(pd.NaT, index=range(4), dtype="datetime64[ns, US/Eastern]") - result = pd.concat([y, y], ignore_index=True) + result = concat([y, y], ignore_index=True) tm.assert_series_equal(result, expected) # without tz - x = Series(pd.date_range("20151124 08:00", "20151124 09:00", freq="1h")) - y = Series(pd.date_range("20151124 10:00", "20151124 11:00", freq="1h")) + x = Series(date_range("20151124 08:00", "20151124 09:00", freq="1h")) + y = Series(date_range("20151124 10:00", "20151124 11:00", freq="1h")) y[:] = pd.NaT expected = Series([x[0], x[1], pd.NaT, pd.NaT]) - result = pd.concat([x, y], ignore_index=True) + result = concat([x, y], ignore_index=True) tm.assert_series_equal(result, expected) # all NaT without tz x[:] = pd.NaT expected = Series(pd.NaT, index=range(4), dtype="datetime64[ns]") - result = pd.concat([x, y], ignore_index=True) + result = concat([x, y], ignore_index=True) tm.assert_series_equal(result, expected) @pytest.mark.parametrize("tz", [None, "UTC"]) @@ -215,7 +213,7 @@ def test_concat_NaT_dataframes(self, tz): ] ) - result = pd.concat([first, second], axis=0) + result = concat([first, second], axis=0) tm.assert_frame_equal(result, expected) @pytest.mark.parametrize("tz1", [None, "UTC"]) @@ -228,7 +226,7 @@ def test_concat_NaT_dataframes_all_NaT_axis_0(self, tz1, tz2, s): first = DataFrame([[pd.NaT], [pd.NaT]]).apply(lambda x: x.dt.tz_localize(tz1)) second = DataFrame([s]).apply(lambda x: x.dt.tz_localize(tz2)) - result = pd.concat([first, second], axis=0) + result = concat([first, second], axis=0) expected = DataFrame(Series([pd.NaT, pd.NaT, s], index=[0, 1, 0])) expected = expected.apply(lambda x: x.dt.tz_localize(tz2)) if tz1 != tz2: @@ -249,7 +247,7 @@ def test_concat_NaT_dataframes_all_NaT_axis_1(self, tz1, tz2): 1: Series([pd.NaT, pd.NaT]).dt.tz_localize(tz2), } ) - result = pd.concat([first, second], axis=1) + result = concat([first, second], axis=1) tm.assert_frame_equal(result, expected) @pytest.mark.parametrize("tz1", [None, "UTC"]) @@ -278,7 +276,7 @@ def test_concat_NaT_series_dataframe_all_NaT(self, tz1, tz2): if tz1 != tz2: expected = expected.astype(object) - result = pd.concat([first, second]) + result = concat([first, second]) tm.assert_frame_equal(result, expected) @@ -306,7 +304,7 @@ def test_concat_tz_series(self): second = DataFrame([[datetime(2016, 1, 2)]]) second[0] = second[0].dt.tz_localize("UTC") - result = pd.concat([first, second]) + result = concat([first, second]) assert result[0].dtype == "datetime64[ns, UTC]" # Concatenating two London times @@ -316,7 +314,7 @@ def test_concat_tz_series(self): second = DataFrame([[datetime(2016, 1, 2)]]) second[0] = second[0].dt.tz_localize("Europe/London") - result = pd.concat([first, second]) + result = concat([first, second]) assert result[0].dtype == "datetime64[ns, Europe/London]" # Concatenating 2+1 London times @@ -326,7 +324,7 @@ def test_concat_tz_series(self): second = DataFrame([[datetime(2016, 1, 3)]]) second[0] = second[0].dt.tz_localize("Europe/London") - result = pd.concat([first, second]) + result = concat([first, second]) assert result[0].dtype == "datetime64[ns, Europe/London]" # Concat'ing 1+2 London times @@ -336,7 +334,7 @@ def test_concat_tz_series(self): second = DataFrame([[datetime(2016, 1, 2)], [datetime(2016, 1, 3)]]) second[0] = second[0].dt.tz_localize("Europe/London") - result = pd.concat([first, second]) + result = concat([first, second]) assert result[0].dtype == "datetime64[ns, Europe/London]" def test_concat_tz_series_tzlocal(self): @@ -379,7 +377,7 @@ def test_concat_tz_frame(self): ) # concat - df3 = pd.concat([df2.A.to_frame(), df2.B.to_frame()], axis=1) + df3 = concat([df2.A.to_frame(), df2.B.to_frame()], axis=1) tm.assert_frame_equal(df2, df3) def test_concat_multiple_tzs(self): @@ -393,15 +391,15 @@ def test_concat_multiple_tzs(self): df2 = DataFrame({"time": [ts2]}) df3 = DataFrame({"time": [ts3]}) - results = pd.concat([df1, df2]).reset_index(drop=True) + results = concat([df1, df2]).reset_index(drop=True) expected = DataFrame({"time": [ts1, ts2]}, dtype=object) tm.assert_frame_equal(results, expected) - results = pd.concat([df1, df3]).reset_index(drop=True) + results = concat([df1, df3]).reset_index(drop=True) expected = DataFrame({"time": [ts1, ts3]}, dtype=object) tm.assert_frame_equal(results, expected) - results = pd.concat([df2, df3]).reset_index(drop=True) + results = concat([df2, df3]).reset_index(drop=True) expected = DataFrame({"time": [ts2, ts3]}) tm.assert_frame_equal(results, expected) @@ -439,7 +437,7 @@ def test_concat_tz_not_aligned(self): ts = pd.to_datetime([1, 2]).tz_localize("UTC") a = DataFrame({"A": ts}) b = DataFrame({"A": ts, "B": ts}) - result = pd.concat([a, b], sort=True, ignore_index=True) + result = concat([a, b], sort=True, ignore_index=True) expected = DataFrame( {"A": list(ts) + list(ts), "B": [pd.NaT, pd.NaT] + list(ts)} ) @@ -467,7 +465,7 @@ def test_concat_tz_NaT(self, t1): df1 = DataFrame([[ts1, ts2]]) df2 = DataFrame([[ts3]]) - result = pd.concat([df1, df2]) + result = concat([df1, df2]) expected = DataFrame([[ts1, ts2], [ts3, pd.NaT]], index=[0, 0]) tm.assert_frame_equal(result, expected) diff --git a/pandas/tests/reshape/concat/test_empty.py b/pandas/tests/reshape/concat/test_empty.py index 0e86cb0ae48c0..ab419e0481973 100644 --- a/pandas/tests/reshape/concat/test_empty.py +++ b/pandas/tests/reshape/concat/test_empty.py @@ -49,7 +49,7 @@ def test_concat_empty_series(self): # GH 11082 s1 = Series([1, 2, 3], name="x") s2 = Series(name="y", dtype="float64") - res = pd.concat([s1, s2], axis=1) + res = concat([s1, s2], axis=1) exp = DataFrame( {"x": [1, 2, 3], "y": [np.nan, np.nan, np.nan]}, index=Index([0, 1, 2], dtype="O"), @@ -58,7 +58,7 @@ def test_concat_empty_series(self): s1 = Series([1, 2, 3], name="x") s2 = Series(name="y", dtype="float64") - res = pd.concat([s1, s2], axis=0) + res = concat([s1, s2], axis=0) # name will be reset exp = Series([1, 2, 3]) tm.assert_series_equal(res, exp) @@ -66,7 +66,7 @@ def test_concat_empty_series(self): # empty Series with no name s1 = Series([1, 2, 3], name="x") s2 = Series(name=None, dtype="float64") - res = pd.concat([s1, s2], axis=1) + res = concat([s1, s2], axis=1) exp = DataFrame( {"x": [1, 2, 3], 0: [np.nan, np.nan, np.nan]}, columns=["x", 0], @@ -109,7 +109,7 @@ def test_concat_empty_series_timelike(self, tz, values): ], ) def test_concat_empty_series_dtypes(self, left, right, expected): - result = pd.concat([Series(dtype=left), Series(dtype=right)]) + result = concat([Series(dtype=left), Series(dtype=right)]) assert result.dtype == expected @pytest.mark.parametrize( @@ -118,10 +118,10 @@ def test_concat_empty_series_dtypes(self, left, right, expected): def test_concat_empty_series_dtypes_match_roundtrips(self, dtype): dtype = np.dtype(dtype) - result = pd.concat([Series(dtype=dtype)]) + result = concat([Series(dtype=dtype)]) assert result.dtype == dtype - result = pd.concat([Series(dtype=dtype), Series(dtype=dtype)]) + result = concat([Series(dtype=dtype), Series(dtype=dtype)]) assert result.dtype == dtype def test_concat_empty_series_dtypes_roundtrips(self): @@ -164,13 +164,13 @@ def get_result_type(dtype, dtype2): continue expected = get_result_type(dtype, dtype2) - result = pd.concat([Series(dtype=dtype), Series(dtype=dtype2)]).dtype + result = concat([Series(dtype=dtype), Series(dtype=dtype2)]).dtype assert result.kind == expected def test_concat_empty_series_dtypes_triple(self): assert ( - pd.concat( + concat( [Series(dtype="M8[ns]"), Series(dtype=np.bool_), Series(dtype=np.int64)] ).dtype == np.object_ @@ -179,14 +179,14 @@ def test_concat_empty_series_dtypes_triple(self): def test_concat_empty_series_dtype_category_with_array(self): # GH#18515 assert ( - pd.concat( + concat( [Series(np.array([]), dtype="category"), Series(dtype="float64")] ).dtype == "float64" ) def test_concat_empty_series_dtypes_sparse(self): - result = pd.concat( + result = concat( [ Series(dtype="float64").astype("Sparse"), Series(dtype="float64").astype("Sparse"), @@ -194,14 +194,14 @@ def test_concat_empty_series_dtypes_sparse(self): ) assert result.dtype == "Sparse[float64]" - result = pd.concat( + result = concat( [Series(dtype="float64").astype("Sparse"), Series(dtype="float64")] ) # TODO: release-note: concat sparse dtype expected = pd.SparseDtype(np.float64) assert result.dtype == expected - result = pd.concat( + result = concat( [Series(dtype="float64").astype("Sparse"), Series(dtype="object")] ) # TODO: release-note: concat sparse dtype @@ -212,7 +212,7 @@ def test_concat_empty_df_object_dtype(self): # GH 9149 df_1 = DataFrame({"Row": [0, 1, 1], "EmptyCol": np.nan, "NumberCol": [1, 2, 3]}) df_2 = DataFrame(columns=df_1.columns) - result = pd.concat([df_1, df_2], axis=0) + result = concat([df_1, df_2], axis=0) expected = df_1.astype(object) tm.assert_frame_equal(result, expected) @@ -222,12 +222,12 @@ def test_concat_empty_dataframe_dtypes(self): df["b"] = df["b"].astype(np.int32) df["c"] = df["c"].astype(np.float64) - result = pd.concat([df, df]) + result = concat([df, df]) assert result["a"].dtype == np.bool_ assert result["b"].dtype == np.int32 assert result["c"].dtype == np.float64 - result = pd.concat([df, df.astype(np.float64)]) + result = concat([df, df.astype(np.float64)]) assert result["a"].dtype == np.object_ assert result["b"].dtype == np.float64 assert result["c"].dtype == np.float64 @@ -239,7 +239,7 @@ def test_concat_inner_join_empty(self): df_expected = DataFrame({"a": []}, index=[], dtype="int64") for how, expected in [("inner", df_expected), ("outer", df_a)]: - result = pd.concat([df_a, df_empty], axis=1, join=how) + result = concat([df_a, df_empty], axis=1, join=how) tm.assert_frame_equal(result, expected) def test_empty_dtype_coerce(self): diff --git a/pandas/tests/reshape/concat/test_index.py b/pandas/tests/reshape/concat/test_index.py index c822dab9b8cfc..bd845f73c7c69 100644 --- a/pandas/tests/reshape/concat/test_index.py +++ b/pandas/tests/reshape/concat/test_index.py @@ -60,7 +60,7 @@ def test_concat_same_index_names(self, name_in1, name_in2, name_in3, name_out): frames = [ DataFrame({c: [0, 1, 2]}, index=i) for i, c in zip(indices, ["x", "y", "z"]) ] - result = pd.concat(frames, axis=1) + result = concat(frames, axis=1) exp_ind = Index(["a", "b", "c", "d", "e"], name=name_out) expected = DataFrame( @@ -113,7 +113,7 @@ def test_default_index(self): # is_series and ignore_index s1 = Series([1, 2, 3], name="x") s2 = Series([4, 5, 6], name="y") - res = pd.concat([s1, s2], axis=1, ignore_index=True) + res = concat([s1, s2], axis=1, ignore_index=True) assert isinstance(res.columns, pd.RangeIndex) exp = DataFrame([[1, 4], [2, 5], [3, 6]]) # use check_index_type=True to check the result have @@ -123,7 +123,7 @@ def test_default_index(self): # is_series and all inputs have no names s1 = Series([1, 2, 3]) s2 = Series([4, 5, 6]) - res = pd.concat([s1, s2], axis=1, ignore_index=False) + res = concat([s1, s2], axis=1, ignore_index=False) assert isinstance(res.columns, pd.RangeIndex) exp = DataFrame([[1, 4], [2, 5], [3, 6]]) exp.columns = pd.RangeIndex(2) @@ -133,11 +133,11 @@ def test_default_index(self): df1 = DataFrame({"A": [1, 2], "B": [5, 6]}) df2 = DataFrame({"A": [3, 4], "B": [7, 8]}) - res = pd.concat([df1, df2], axis=0, ignore_index=True) + res = concat([df1, df2], axis=0, ignore_index=True) exp = DataFrame([[1, 5], [2, 6], [3, 7], [4, 8]], columns=["A", "B"]) tm.assert_frame_equal(res, exp, check_index_type=True, check_column_type=True) - res = pd.concat([df1, df2], axis=1, ignore_index=True) + res = concat([df1, df2], axis=1, ignore_index=True) exp = DataFrame([[1, 5, 3, 7], [2, 6, 4, 8]]) tm.assert_frame_equal(res, exp, check_index_type=True, check_column_type=True) @@ -261,7 +261,7 @@ def test_concat_multiindex_dfs_with_deepcopy(self): names=["testname", None, None], ) expected = DataFrame([[0], [1]], index=expected_index) - result_copy = pd.concat(deepcopy(example_dict), names=["testname"]) + result_copy = concat(deepcopy(example_dict), names=["testname"]) tm.assert_frame_equal(result_copy, expected) - result_no_copy = pd.concat(example_dict, names=["testname"]) + result_no_copy = concat(example_dict, names=["testname"]) tm.assert_frame_equal(result_no_copy, expected) diff --git a/pandas/tests/reshape/concat/test_series.py b/pandas/tests/reshape/concat/test_series.py index 44e29f08f282e..34bba581b31c7 100644 --- a/pandas/tests/reshape/concat/test_series.py +++ b/pandas/tests/reshape/concat/test_series.py @@ -1,7 +1,6 @@ import numpy as np import pytest -import pandas as pd from pandas import ( DataFrame, DatetimeIndex, @@ -48,7 +47,7 @@ def test_concat_empty_and_non_empty_series_regression(self): s2 = Series([], dtype=object) expected = s1 - result = pd.concat([s1, s2]) + result = concat([s1, s2]) tm.assert_series_equal(result, expected) def test_concat_series_axis1(self, sort=sort): @@ -117,7 +116,7 @@ def test_concat_series_name_npscalar_tuple(self, s1name, s2name): # GH21015 s1 = Series({"a": 1, "b": 2}, name=s1name) s2 = Series({"c": 5, "d": 6}, name=s2name) - result = pd.concat([s1, s2]) + result = concat([s1, s2]) expected = Series({"a": 1, "b": 2, "c": 5, "d": 6}) tm.assert_series_equal(result, expected) @@ -147,5 +146,5 @@ def test_concat_series_partial_columns_names(self): def test_concat_series_length_one_reversed(self, frame_or_series): # GH39401 obj = frame_or_series([100]) - result = pd.concat([obj.iloc[::-1]]) + result = concat([obj.iloc[::-1]]) tm.assert_equal(result, obj) diff --git a/pandas/tests/reshape/merge/test_join.py b/pandas/tests/reshape/merge/test_join.py index 2ec94d4cebf5a..d31930aa233cd 100644 --- a/pandas/tests/reshape/merge/test_join.py +++ b/pandas/tests/reshape/merge/test_join.py @@ -836,15 +836,13 @@ def test_join_cross(input_col, output_cols): def test_join_multiindex_one_level(join_type): # GH#36909 left = DataFrame( - data={"c": 3}, index=pd.MultiIndex.from_tuples([(1, 2)], names=("a", "b")) - ) - right = DataFrame( - data={"d": 4}, index=pd.MultiIndex.from_tuples([(2,)], names=("b",)) + data={"c": 3}, index=MultiIndex.from_tuples([(1, 2)], names=("a", "b")) ) + right = DataFrame(data={"d": 4}, index=MultiIndex.from_tuples([(2,)], names=("b",))) result = left.join(right, how=join_type) expected = DataFrame( {"c": [3], "d": [4]}, - index=pd.MultiIndex.from_tuples([(2, 1)], names=["b", "a"]), + index=MultiIndex.from_tuples([(2, 1)], names=["b", "a"]), ) tm.assert_frame_equal(result, expected) diff --git a/pandas/tests/reshape/merge/test_merge.py b/pandas/tests/reshape/merge/test_merge.py index e1b1e80a29a43..4fa2865a9e320 100644 --- a/pandas/tests/reshape/merge/test_merge.py +++ b/pandas/tests/reshape/merge/test_merge.py @@ -134,7 +134,7 @@ def test_merge_inner_join_empty(self): # GH 15328 df_empty = DataFrame() df_a = DataFrame({"a": [1, 2]}, index=[0, 1], dtype="int64") - result = pd.merge(df_empty, df_a, left_index=True, right_index=True) + result = merge(df_empty, df_a, left_index=True, right_index=True) expected = DataFrame({"a": []}, index=[], dtype="int64") tm.assert_frame_equal(result, expected) @@ -152,7 +152,7 @@ def test_merge_non_string_columns(self): right = left.astype(float) expected = left - result = pd.merge(left, right) + result = merge(left, right) tm.assert_frame_equal(expected, result) def test_merge_index_as_on_arg(self): @@ -459,7 +459,7 @@ def test_merge_left_empty_right_empty(self, join_type, kwarg): dtype=object, ) - result = pd.merge(left, right, how=join_type, **kwarg) + result = merge(left, right, how=join_type, **kwarg) tm.assert_frame_equal(result, exp_in) def test_merge_left_empty_right_notempty(self): @@ -483,15 +483,15 @@ def test_merge_left_empty_right_notempty(self): exp_in.index = exp_in.index.astype(object) def check1(exp, kwarg): - result = pd.merge(left, right, how="inner", **kwarg) + result = merge(left, right, how="inner", **kwarg) tm.assert_frame_equal(result, exp) - result = pd.merge(left, right, how="left", **kwarg) + result = merge(left, right, how="left", **kwarg) tm.assert_frame_equal(result, exp) def check2(exp, kwarg): - result = pd.merge(left, right, how="right", **kwarg) + result = merge(left, right, how="right", **kwarg) tm.assert_frame_equal(result, exp) - result = pd.merge(left, right, how="outer", **kwarg) + result = merge(left, right, how="outer", **kwarg) tm.assert_frame_equal(result, exp) for kwarg in [ @@ -532,15 +532,15 @@ def test_merge_left_notempty_right_empty(self): exp_in.index = exp_in.index.astype(object) def check1(exp, kwarg): - result = pd.merge(left, right, how="inner", **kwarg) + result = merge(left, right, how="inner", **kwarg) tm.assert_frame_equal(result, exp) - result = pd.merge(left, right, how="right", **kwarg) + result = merge(left, right, how="right", **kwarg) tm.assert_frame_equal(result, exp) def check2(exp, kwarg): - result = pd.merge(left, right, how="left", **kwarg) + result = merge(left, right, how="left", **kwarg) tm.assert_frame_equal(result, exp) - result = pd.merge(left, right, how="outer", **kwarg) + result = merge(left, right, how="outer", **kwarg) tm.assert_frame_equal(result, exp) for kwarg in [ @@ -800,7 +800,7 @@ def test_merge_on_datetime64tz(self): "value_y": [np.nan, 1, 2, 3], } ) - result = pd.merge(left, right, on="key", how="outer") + result = merge(left, right, on="key", how="outer") tm.assert_frame_equal(result, expected) left = DataFrame( @@ -824,7 +824,7 @@ def test_merge_on_datetime64tz(self): + list(pd.date_range("20151011", periods=2, tz="US/Eastern")), } ) - result = pd.merge(left, right, on="key", how="outer") + result = merge(left, right, on="key", how="outer") tm.assert_frame_equal(result, expected) assert result["value_x"].dtype == "datetime64[ns, US/Eastern]" assert result["value_y"].dtype == "datetime64[ns, US/Eastern]" @@ -874,7 +874,7 @@ def test_merge_datetime64tz_with_dst_transition(self): } ) df2["date"] = df2["date"].dt.tz_localize("UTC").dt.tz_convert("Europe/Madrid") - result = pd.merge(df1, df2, how="outer", on="date") + result = merge(df1, df2, how="outer", on="date") expected = DataFrame( { "date": pd.date_range( @@ -917,7 +917,7 @@ def test_merge_on_periods(self): "value_y": [np.nan, 1, 2, 3], } ) - result = pd.merge(left, right, on="key", how="outer") + result = merge(left, right, on="key", how="outer") tm.assert_frame_equal(result, expected) left = DataFrame( @@ -936,7 +936,7 @@ def test_merge_on_periods(self): "value_y": [pd.NaT] + list(exp_y), } ) - result = pd.merge(left, right, on="key", how="outer") + result = merge(left, right, on="key", how="outer") tm.assert_frame_equal(result, expected) assert result["value_x"].dtype == "Period[D]" assert result["value_y"].dtype == "Period[D]" @@ -1430,7 +1430,7 @@ def test_different(self, right_vals): # GH 9780 # We allow merging on object and categorical cols and cast # categorical cols to object - result = pd.merge(left, right, on="A") + result = merge(left, right, on="A") assert is_object_dtype(result.A.dtype) @pytest.mark.parametrize("d1", [np.int64, np.int32, np.int16, np.int8, np.uint8]) @@ -1530,9 +1530,9 @@ def test_merge_incompat_infer_boolean_object(self): df2 = DataFrame({"key": [True, False]}) expected = DataFrame({"key": [True, False]}, dtype=object) - result = pd.merge(df1, df2, on="key") + result = merge(df1, df2, on="key") tm.assert_frame_equal(result, expected) - result = pd.merge(df2, df1, on="key") + result = merge(df2, df1, on="key") tm.assert_frame_equal(result, expected) # with missing value @@ -1540,9 +1540,9 @@ def test_merge_incompat_infer_boolean_object(self): df2 = DataFrame({"key": [True, False]}) expected = DataFrame({"key": [True, False]}, dtype=object) - result = pd.merge(df1, df2, on="key") + result = merge(df1, df2, on="key") tm.assert_frame_equal(result, expected) - result = pd.merge(df2, df1, on="key") + result = merge(df2, df1, on="key") tm.assert_frame_equal(result, expected) @pytest.mark.parametrize( @@ -1564,9 +1564,9 @@ def test_merge_incompat_dtypes_are_ok(self, df1_vals, df2_vals): df1 = DataFrame({"A": df1_vals}) df2 = DataFrame({"A": df2_vals}) - result = pd.merge(df1, df2, on=["A"]) + result = merge(df1, df2, on=["A"]) assert is_object_dtype(result.A.dtype) - result = pd.merge(df2, df1, on=["A"]) + result = merge(df2, df1, on=["A"]) assert is_object_dtype(result.A.dtype) @pytest.mark.parametrize( @@ -1605,7 +1605,7 @@ def test_merge_incompat_dtypes_error(self, df1_vals, df2_vals): ) msg = re.escape(msg) with pytest.raises(ValueError, match=msg): - pd.merge(df1, df2, on=["A"]) + merge(df1, df2, on=["A"]) # Check that error still raised when swapping order of dataframes msg = ( @@ -1615,7 +1615,7 @@ def test_merge_incompat_dtypes_error(self, df1_vals, df2_vals): ) msg = re.escape(msg) with pytest.raises(ValueError, match=msg): - pd.merge(df2, df1, on=["A"]) + merge(df2, df1, on=["A"]) @pytest.fixture @@ -1642,7 +1642,7 @@ def right(): class TestMergeCategorical: def test_identical(self, left): # merging on the same, should preserve dtypes - merged = pd.merge(left, left, on="X") + merged = merge(left, left, on="X") result = merged.dtypes.sort_index() expected = Series( [CategoricalDtype(categories=["foo", "bar"]), np.dtype("O"), np.dtype("O")], @@ -1653,7 +1653,7 @@ def test_identical(self, left): def test_basic(self, left, right): # we have matching Categorical dtypes in X # so should preserve the merged column - merged = pd.merge(left, right, on="X") + merged = merge(left, right, on="X") result = merged.dtypes.sort_index() expected = Series( [ @@ -1680,7 +1680,7 @@ def test_merge_categorical(self): "b": {0: "g", 1: "g", 2: "g", 3: "g", 4: "g"}, } ) - df = pd.merge(left, right, how="left", left_on="b", right_on="c") + df = merge(left, right, how="left", left_on="b", right_on="c") # object-object expected = df.copy() @@ -1690,14 +1690,14 @@ def test_merge_categorical(self): # because we don't have any matching rows cright = right.copy() cright["d"] = cright["d"].astype("category") - result = pd.merge(left, cright, how="left", left_on="b", right_on="c") + result = merge(left, cright, how="left", left_on="b", right_on="c") expected["d"] = expected["d"].astype(CategoricalDtype(["null"])) tm.assert_frame_equal(result, expected) # cat-object cleft = left.copy() cleft["b"] = cleft["b"].astype("category") - result = pd.merge(cleft, cright, how="left", left_on="b", right_on="c") + result = merge(cleft, cright, how="left", left_on="b", right_on="c") tm.assert_frame_equal(result, expected) # cat-cat @@ -1705,7 +1705,7 @@ def test_merge_categorical(self): cright["d"] = cright["d"].astype("category") cleft = left.copy() cleft["b"] = cleft["b"].astype("category") - result = pd.merge(cleft, cright, how="left", left_on="b", right_on="c") + result = merge(cleft, cright, how="left", left_on="b", right_on="c") tm.assert_frame_equal(result, expected) def tests_merge_categorical_unordered_equal(self): @@ -1723,7 +1723,7 @@ def tests_merge_categorical_unordered_equal(self): "Right": ["C1", "B1", "A1"], } ) - result = pd.merge(df1, df2, on=["Foo"]) + result = merge(df1, df2, on=["Foo"]) expected = DataFrame( { "Foo": Categorical(["A", "B", "C"]), @@ -1737,7 +1737,7 @@ def test_other_columns(self, left, right): # non-merge columns should preserve if possible right = right.assign(Z=right.Z.astype("category")) - merged = pd.merge(left, right, on="X") + merged = merge(left, right, on="X") result = merged.dtypes.sort_index() expected = Series( [ @@ -1770,7 +1770,7 @@ def test_dtype_on_merged_different(self, change, join_type, left, right): assert is_categorical_dtype(left.X.values.dtype) # assert not left.X.values._categories_match_up_to_permutation(right.X.values) - merged = pd.merge(left, right, on="X", how=join_type) + merged = merge(left, right, on="X", how=join_type) result = merged.dtypes.sort_index() expected = Series( @@ -1814,7 +1814,7 @@ def test_self_join_multiple_categories(self): df = df.apply(lambda x: x.astype("category")) # self-join should equal ourselves - result = pd.merge(df, df, on=list(df.columns)) + result = merge(df, df, on=list(df.columns)) tm.assert_frame_equal(result, df) @@ -1840,14 +1840,14 @@ def test_dtype_on_categorical_dates(self): ], columns=["date", "num2", "num4"], ) - result_outer = pd.merge(df, df2, how="outer", on=["date"]) + result_outer = merge(df, df2, how="outer", on=["date"]) tm.assert_frame_equal(result_outer, expected_outer) expected_inner = DataFrame( [[pd.Timestamp("2001-01-01").date(), 1.1, 1.3]], columns=["date", "num2", "num4"], ) - result_inner = pd.merge(df, df2, how="inner", on=["date"]) + result_inner = merge(df, df2, how="inner", on=["date"]) tm.assert_frame_equal(result_inner, expected_inner) @pytest.mark.parametrize("ordered", [True, False]) @@ -1875,7 +1875,7 @@ def test_merging_with_bool_or_int_cateorical_column( def test_merge_on_int_array(self): # GH 23020 df = DataFrame({"A": Series([1, 2, np.nan], dtype="Int64"), "B": 1}) - result = pd.merge(df, df, on="A") + result = merge(df, df, on="A") expected = DataFrame( {"A": Series([1, 2, np.nan], dtype="Int64"), "B_x": 1, "B_y": 1} ) @@ -1941,7 +1941,7 @@ class TestMergeOnIndexes: ], ) def test_merge_on_indexes(self, left_df, right_df, how, sort, expected): - result = pd.merge( + result = merge( left_df, right_df, left_index=True, right_index=True, how=how, sort=sort ) tm.assert_frame_equal(result, expected) @@ -1988,23 +1988,19 @@ def test_merge_series(on, left_on, right_on, left_index, right_index, nm): # GH 21220 a = DataFrame( {"A": [1, 2, 3, 4]}, - index=pd.MultiIndex.from_product( - [["a", "b"], [0, 1]], names=["outer", "inner"] - ), + index=MultiIndex.from_product([["a", "b"], [0, 1]], names=["outer", "inner"]), ) b = Series( [1, 2, 3, 4], - index=pd.MultiIndex.from_product( - [["a", "b"], [1, 2]], names=["outer", "inner"] - ), + index=MultiIndex.from_product([["a", "b"], [1, 2]], names=["outer", "inner"]), name=nm, ) expected = DataFrame( {"A": [2, 4], "B": [1, 3]}, - index=pd.MultiIndex.from_product([["a", "b"], [1]], names=["outer", "inner"]), + index=MultiIndex.from_product([["a", "b"], [1]], names=["outer", "inner"]), ) if nm is not None: - result = pd.merge( + result = merge( a, b, on=on, @@ -2017,7 +2013,7 @@ def test_merge_series(on, left_on, right_on, left_index, right_index, nm): else: msg = "Cannot merge a Series without a name" with pytest.raises(ValueError, match=msg): - result = pd.merge( + result = merge( a, b, on=on, @@ -2056,7 +2052,7 @@ def test_merge_suffix(col1, col2, kwargs, expected_cols): result = a.merge(b, left_index=True, right_index=True, **kwargs) tm.assert_frame_equal(result, expected) - result = pd.merge(a, b, left_index=True, right_index=True, **kwargs) + result = merge(a, b, left_index=True, right_index=True, **kwargs) tm.assert_frame_equal(result, expected) @@ -2102,7 +2098,7 @@ def test_merge_suffix_error(col1, col2, suffixes): # TODO: might reconsider current raise behaviour, see issue 24782 msg = "columns overlap but no suffix specified" with pytest.raises(ValueError, match=msg): - pd.merge(a, b, left_index=True, right_index=True, suffixes=suffixes) + merge(a, b, left_index=True, right_index=True, suffixes=suffixes) @pytest.mark.parametrize("suffixes", [{"left", "right"}, {"left": 0, "right": 0}]) @@ -2111,7 +2107,7 @@ def test_merge_suffix_warns(suffixes): b = DataFrame({"b": [3, 4, 5]}) with tm.assert_produces_warning(FutureWarning): - pd.merge(a, b, left_index=True, right_index=True, suffixes={"left", "right"}) + merge(a, b, left_index=True, right_index=True, suffixes={"left", "right"}) @pytest.mark.parametrize( @@ -2126,7 +2122,7 @@ def test_merge_suffix_length_error(col1, col2, suffixes, msg): b = DataFrame({col2: [3, 4, 5]}) with pytest.raises(ValueError, match=msg): - pd.merge(a, b, left_index=True, right_index=True, suffixes=suffixes) + merge(a, b, left_index=True, right_index=True, suffixes=suffixes) @pytest.mark.parametrize("cat_dtype", ["one", "two"]) @@ -2196,7 +2192,7 @@ def test_merge_on_cat_and_ext_array(): left = right.copy() left["a"] = left["a"].astype("category") - result = pd.merge(left, right, how="inner", on="a") + result = merge(left, right, how="inner", on="a") expected = right.copy() tm.assert_frame_equal(result, expected) @@ -2210,7 +2206,7 @@ def test_merge_multiindex_columns(): letters = ["a", "b", "c", "d"] numbers = ["1", "2", "3"] - index = pd.MultiIndex.from_product((letters, numbers), names=["outer", "inner"]) + index = MultiIndex.from_product((letters, numbers), names=["outer", "inner"]) frame_x = DataFrame(columns=index) frame_x["id"] = "" @@ -2225,7 +2221,7 @@ def test_merge_multiindex_columns(): expected_labels = [letter + l_suf for letter in letters] + [ letter + r_suf for letter in letters ] - expected_index = pd.MultiIndex.from_product( + expected_index = MultiIndex.from_product( [expected_labels, numbers], names=["outer", "inner"] ) expected = DataFrame(columns=expected_index) @@ -2240,7 +2236,7 @@ def test_merge_datetime_upcast_dtype(): df2 = DataFrame( {"y": ["1", "2", "3"], "z": pd.to_datetime(["2000", "2001", "2002"])} ) - result = pd.merge(df1, df2, how="left", on="y") + result = merge(df1, df2, how="left", on="y") expected = DataFrame( { "x": ["a", "b", "c"], @@ -2387,7 +2383,7 @@ def test_merge_right_left_index(): # GH#38616 left = DataFrame({"x": [1, 1], "z": ["foo", "foo"]}) right = DataFrame({"x": [1, 1], "z": ["foo", "foo"]}) - result = pd.merge(left, right, how="right", left_index=True, right_on="x") + result = merge(left, right, how="right", left_index=True, right_on="x") expected = DataFrame( { "x": [1, 1], diff --git a/pandas/tests/reshape/merge/test_merge_asof.py b/pandas/tests/reshape/merge/test_merge_asof.py index 5fa08904e3fcf..3f5bb9b84372c 100644 --- a/pandas/tests/reshape/merge/test_merge_asof.py +++ b/pandas/tests/reshape/merge/test_merge_asof.py @@ -47,14 +47,14 @@ def test_examples1(self): {"a": [1, 5, 10], "left_val": ["a", "b", "c"], "right_val": [1, 3, 7]} ) - result = pd.merge_asof(left, right, on="a") + result = merge_asof(left, right, on="a") tm.assert_frame_equal(result, expected) def test_examples2(self): """ doc-string examples """ trades = pd.DataFrame( { - "time": pd.to_datetime( + "time": to_datetime( [ "20160525 13:30:00.023", "20160525 13:30:00.038", @@ -72,7 +72,7 @@ def test_examples2(self): quotes = pd.DataFrame( { - "time": pd.to_datetime( + "time": to_datetime( [ "20160525 13:30:00.023", "20160525 13:30:00.023", @@ -100,15 +100,13 @@ def test_examples2(self): columns=["time", "ticker", "bid", "ask"], ) - pd.merge_asof(trades, quotes, on="time", by="ticker") + merge_asof(trades, quotes, on="time", by="ticker") - pd.merge_asof( - trades, quotes, on="time", by="ticker", tolerance=Timedelta("2ms") - ) + merge_asof(trades, quotes, on="time", by="ticker", tolerance=Timedelta("2ms")) expected = pd.DataFrame( { - "time": pd.to_datetime( + "time": to_datetime( [ "20160525 13:30:00.023", "20160525 13:30:00.038", @@ -126,7 +124,7 @@ def test_examples2(self): columns=["time", "ticker", "price", "quantity", "bid", "ask"], ) - result = pd.merge_asof( + result = merge_asof( trades, quotes, on="time", @@ -147,7 +145,7 @@ def test_examples3(self): {"a": [1, 5, 10], "left_val": ["a", "b", "c"], "right_val": [1, 6, np.nan]} ) - result = pd.merge_asof(left, right, on="a", direction="forward") + result = merge_asof(left, right, on="a", direction="forward") tm.assert_frame_equal(result, expected) def test_examples4(self): @@ -161,7 +159,7 @@ def test_examples4(self): {"a": [1, 5, 10], "left_val": ["a", "b", "c"], "right_val": [1, 6, 7]} ) - result = pd.merge_asof(left, right, on="a", direction="nearest") + result = merge_asof(left, right, on="a", direction="nearest") tm.assert_frame_equal(result, expected) def test_basic(self): @@ -282,7 +280,7 @@ def test_multiby(self): # GH13936 trades = pd.DataFrame( { - "time": pd.to_datetime( + "time": to_datetime( [ "20160525 13:30:00.023", "20160525 13:30:00.023", @@ -301,7 +299,7 @@ def test_multiby(self): quotes = pd.DataFrame( { - "time": pd.to_datetime( + "time": to_datetime( [ "20160525 13:30:00.023", "20160525 13:30:00.023", @@ -321,7 +319,7 @@ def test_multiby(self): expected = pd.DataFrame( { - "time": pd.to_datetime( + "time": to_datetime( [ "20160525 13:30:00.023", "20160525 13:30:00.023", @@ -340,14 +338,14 @@ def test_multiby(self): columns=["time", "ticker", "exch", "price", "quantity", "bid", "ask"], ) - result = pd.merge_asof(trades, quotes, on="time", by=["ticker", "exch"]) + result = merge_asof(trades, quotes, on="time", by=["ticker", "exch"]) tm.assert_frame_equal(result, expected) def test_multiby_heterogeneous_types(self): # GH13936 trades = pd.DataFrame( { - "time": pd.to_datetime( + "time": to_datetime( [ "20160525 13:30:00.023", "20160525 13:30:00.023", @@ -366,7 +364,7 @@ def test_multiby_heterogeneous_types(self): quotes = pd.DataFrame( { - "time": pd.to_datetime( + "time": to_datetime( [ "20160525 13:30:00.023", "20160525 13:30:00.023", @@ -386,7 +384,7 @@ def test_multiby_heterogeneous_types(self): expected = pd.DataFrame( { - "time": pd.to_datetime( + "time": to_datetime( [ "20160525 13:30:00.023", "20160525 13:30:00.023", @@ -405,42 +403,42 @@ def test_multiby_heterogeneous_types(self): columns=["time", "ticker", "exch", "price", "quantity", "bid", "ask"], ) - result = pd.merge_asof(trades, quotes, on="time", by=["ticker", "exch"]) + result = merge_asof(trades, quotes, on="time", by=["ticker", "exch"]) tm.assert_frame_equal(result, expected) def test_multiby_indexed(self): # GH15676 left = pd.DataFrame( [ - [pd.to_datetime("20160602"), 1, "a"], - [pd.to_datetime("20160602"), 2, "a"], - [pd.to_datetime("20160603"), 1, "b"], - [pd.to_datetime("20160603"), 2, "b"], + [to_datetime("20160602"), 1, "a"], + [to_datetime("20160602"), 2, "a"], + [to_datetime("20160603"), 1, "b"], + [to_datetime("20160603"), 2, "b"], ], columns=["time", "k1", "k2"], ).set_index("time") right = pd.DataFrame( [ - [pd.to_datetime("20160502"), 1, "a", 1.0], - [pd.to_datetime("20160502"), 2, "a", 2.0], - [pd.to_datetime("20160503"), 1, "b", 3.0], - [pd.to_datetime("20160503"), 2, "b", 4.0], + [to_datetime("20160502"), 1, "a", 1.0], + [to_datetime("20160502"), 2, "a", 2.0], + [to_datetime("20160503"), 1, "b", 3.0], + [to_datetime("20160503"), 2, "b", 4.0], ], columns=["time", "k1", "k2", "value"], ).set_index("time") expected = pd.DataFrame( [ - [pd.to_datetime("20160602"), 1, "a", 1.0], - [pd.to_datetime("20160602"), 2, "a", 2.0], - [pd.to_datetime("20160603"), 1, "b", 3.0], - [pd.to_datetime("20160603"), 2, "b", 4.0], + [to_datetime("20160602"), 1, "a", 1.0], + [to_datetime("20160602"), 2, "a", 2.0], + [to_datetime("20160603"), 1, "b", 3.0], + [to_datetime("20160603"), 2, "b", 4.0], ], columns=["time", "k1", "k2", "value"], ).set_index("time") - result = pd.merge_asof( + result = merge_asof( left, right, left_index=True, right_index=True, by=["k1", "k2"] ) @@ -449,7 +447,7 @@ def test_multiby_indexed(self): with pytest.raises( MergeError, match="left_by and right_by must be same length" ): - pd.merge_asof( + merge_asof( left, right, left_index=True, @@ -629,7 +627,7 @@ def test_tolerance_forward(self): {"a": [1, 5, 10], "left_val": ["a", "b", "c"], "right_val": [1, np.nan, 11]} ) - result = pd.merge_asof(left, right, on="a", direction="forward", tolerance=1) + result = merge_asof(left, right, on="a", direction="forward", tolerance=1) tm.assert_frame_equal(result, expected) def test_tolerance_nearest(self): @@ -642,7 +640,7 @@ def test_tolerance_nearest(self): {"a": [1, 5, 10], "left_val": ["a", "b", "c"], "right_val": [1, np.nan, 11]} ) - result = pd.merge_asof(left, right, on="a", direction="nearest", tolerance=1) + result = merge_asof(left, right, on="a", direction="nearest", tolerance=1) tm.assert_frame_equal(result, expected) def test_tolerance_tz(self): @@ -650,7 +648,7 @@ def test_tolerance_tz(self): left = pd.DataFrame( { "date": pd.date_range( - start=pd.to_datetime("2016-01-02"), + start=to_datetime("2016-01-02"), freq="D", periods=5, tz=pytz.timezone("UTC"), @@ -661,7 +659,7 @@ def test_tolerance_tz(self): right = pd.DataFrame( { "date": pd.date_range( - start=pd.to_datetime("2016-01-01"), + start=to_datetime("2016-01-01"), freq="D", periods=5, tz=pytz.timezone("UTC"), @@ -669,12 +667,12 @@ def test_tolerance_tz(self): "value2": list("ABCDE"), } ) - result = pd.merge_asof(left, right, on="date", tolerance=Timedelta("1 day")) + result = merge_asof(left, right, on="date", tolerance=Timedelta("1 day")) expected = pd.DataFrame( { "date": pd.date_range( - start=pd.to_datetime("2016-01-02"), + start=to_datetime("2016-01-02"), freq="D", periods=5, tz=pytz.timezone("UTC"), @@ -700,7 +698,7 @@ def test_tolerance_float(self): } ) - result = pd.merge_asof(left, right, on="a", direction="nearest", tolerance=0.5) + result = merge_asof(left, right, on="a", direction="nearest", tolerance=0.5) tm.assert_frame_equal(result, expected) def test_index_tolerance(self): @@ -709,7 +707,7 @@ def test_index_tolerance(self): trades = self.trades.set_index("time") quotes = self.quotes.set_index("time") - result = pd.merge_asof( + result = merge_asof( trades, quotes, left_index=True, @@ -737,7 +735,7 @@ def test_allow_exact_matches_forward(self): {"a": [1, 5, 10], "left_val": ["a", "b", "c"], "right_val": [2, 7, 11]} ) - result = pd.merge_asof( + result = merge_asof( left, right, on="a", direction="forward", allow_exact_matches=False ) tm.assert_frame_equal(result, expected) @@ -752,7 +750,7 @@ def test_allow_exact_matches_nearest(self): {"a": [1, 5, 10], "left_val": ["a", "b", "c"], "right_val": [2, 3, 11]} ) - result = pd.merge_asof( + result = merge_asof( left, right, on="a", direction="nearest", allow_exact_matches=False ) tm.assert_frame_equal(result, expected) @@ -773,38 +771,38 @@ def test_allow_exact_matches_and_tolerance(self): def test_allow_exact_matches_and_tolerance2(self): # GH 13695 df1 = pd.DataFrame( - {"time": pd.to_datetime(["2016-07-15 13:30:00.030"]), "username": ["bob"]} + {"time": to_datetime(["2016-07-15 13:30:00.030"]), "username": ["bob"]} ) df2 = pd.DataFrame( { - "time": pd.to_datetime( + "time": to_datetime( ["2016-07-15 13:30:00.000", "2016-07-15 13:30:00.030"] ), "version": [1, 2], } ) - result = pd.merge_asof(df1, df2, on="time") + result = merge_asof(df1, df2, on="time") expected = pd.DataFrame( { - "time": pd.to_datetime(["2016-07-15 13:30:00.030"]), + "time": to_datetime(["2016-07-15 13:30:00.030"]), "username": ["bob"], "version": [2], } ) tm.assert_frame_equal(result, expected) - result = pd.merge_asof(df1, df2, on="time", allow_exact_matches=False) + result = merge_asof(df1, df2, on="time", allow_exact_matches=False) expected = pd.DataFrame( { - "time": pd.to_datetime(["2016-07-15 13:30:00.030"]), + "time": to_datetime(["2016-07-15 13:30:00.030"]), "username": ["bob"], "version": [1], } ) tm.assert_frame_equal(result, expected) - result = pd.merge_asof( + result = merge_asof( df1, df2, on="time", @@ -813,7 +811,7 @@ def test_allow_exact_matches_and_tolerance2(self): ) expected = pd.DataFrame( { - "time": pd.to_datetime(["2016-07-15 13:30:00.030"]), + "time": to_datetime(["2016-07-15 13:30:00.030"]), "username": ["bob"], "version": [np.nan], } @@ -824,7 +822,7 @@ def test_allow_exact_matches_and_tolerance3(self): # GH 13709 df1 = pd.DataFrame( { - "time": pd.to_datetime( + "time": to_datetime( ["2016-07-15 13:30:00.030", "2016-07-15 13:30:00.030"] ), "username": ["bob", "charlie"], @@ -832,14 +830,14 @@ def test_allow_exact_matches_and_tolerance3(self): ) df2 = pd.DataFrame( { - "time": pd.to_datetime( + "time": to_datetime( ["2016-07-15 13:30:00.000", "2016-07-15 13:30:00.030"] ), "version": [1, 2], } ) - result = pd.merge_asof( + result = merge_asof( df1, df2, on="time", @@ -848,7 +846,7 @@ def test_allow_exact_matches_and_tolerance3(self): ) expected = pd.DataFrame( { - "time": pd.to_datetime( + "time": to_datetime( ["2016-07-15 13:30:00.030", "2016-07-15 13:30:00.030"] ), "username": ["bob", "charlie"], @@ -867,7 +865,7 @@ def test_allow_exact_matches_and_tolerance_forward(self): {"a": [1, 5, 10], "left_val": ["a", "b", "c"], "right_val": [np.nan, 6, 11]} ) - result = pd.merge_asof( + result = merge_asof( left, right, on="a", @@ -887,7 +885,7 @@ def test_allow_exact_matches_and_tolerance_nearest(self): {"a": [1, 5, 10], "left_val": ["a", "b", "c"], "right_val": [np.nan, 4, 11]} ) - result = pd.merge_asof( + result = merge_asof( left, right, on="a", @@ -924,7 +922,7 @@ def test_forward_by(self): } ) - result = pd.merge_asof(left, right, on="a", by="b", direction="forward") + result = merge_asof(left, right, on="a", by="b", direction="forward") tm.assert_frame_equal(result, expected) def test_nearest_by(self): @@ -954,14 +952,14 @@ def test_nearest_by(self): } ) - result = pd.merge_asof(left, right, on="a", by="b", direction="nearest") + result = merge_asof(left, right, on="a", by="b", direction="nearest") tm.assert_frame_equal(result, expected) def test_by_int(self): # we specialize by type, so test that this is correct df1 = pd.DataFrame( { - "time": pd.to_datetime( + "time": to_datetime( [ "20160525 13:30:00.020", "20160525 13:30:00.030", @@ -978,7 +976,7 @@ def test_by_int(self): df2 = pd.DataFrame( { - "time": pd.to_datetime( + "time": to_datetime( [ "20160525 13:30:00.015", "20160525 13:30:00.020", @@ -996,11 +994,11 @@ def test_by_int(self): columns=["time", "key", "value2"], ) - result = pd.merge_asof(df1, df2, on="time", by="key") + result = merge_asof(df1, df2, on="time", by="key") expected = pd.DataFrame( { - "time": pd.to_datetime( + "time": to_datetime( [ "20160525 13:30:00.020", "20160525 13:30:00.030", @@ -1035,7 +1033,7 @@ def test_on_float(self): df1 = df1.sort_values("price").reset_index(drop=True) - result = pd.merge_asof(df1, df2, on="price") + result = merge_asof(df1, df2, on="price") expected = pd.DataFrame( { @@ -1065,7 +1063,7 @@ def test_on_specialized_type(self, any_real_dtype): df2.value = dtype(df2.value) df1 = df1.sort_values("value").reset_index(drop=True) - result = pd.merge_asof(df1, df2, on="value") + result = merge_asof(df1, df2, on="value") expected = pd.DataFrame( { @@ -1100,7 +1098,7 @@ def test_on_specialized_type_by_int(self, any_real_dtype): df2.value = dtype(df2.value) df1 = df1.sort_values("value").reset_index(drop=True) - result = pd.merge_asof(df1, df2, on="value", by="key") + result = merge_asof(df1, df2, on="value", by="key") expected = pd.DataFrame( { @@ -1148,7 +1146,7 @@ def test_on_float_by_int(self): df1 = df1.sort_values("price").reset_index(drop=True) df2 = df2.sort_values("price").reset_index(drop=True) - result = pd.merge_asof(df1, df2, on="price", by="exch") + result = merge_asof(df1, df2, on="price", by="exch") expected = pd.DataFrame( { @@ -1241,7 +1239,7 @@ def test_merge_by_col_tz_aware(self): "values": ["b"], } ) - result = pd.merge_asof(left, right, by="by_col", on="on_col") + result = merge_asof(left, right, by="by_col", on="on_col") expected = pd.DataFrame( [[pd.Timestamp("2018-01-01", tz="UTC"), 2, "a", "b"]], columns=["by_col", "on_col", "values_x", "values_y"], @@ -1266,7 +1264,7 @@ def test_by_mixed_tz_aware(self): "value": ["b"], } ) - result = pd.merge_asof(left, right, by=["by_col1", "by_col2"], on="on_col") + result = merge_asof(left, right, by=["by_col1", "by_col2"], on="on_col") expected = pd.DataFrame( [[pd.Timestamp("2018-01-01", tz="UTC"), "HELLO", 2, "a"]], columns=["by_col1", "by_col2", "on_col", "value_x"], @@ -1304,7 +1302,7 @@ def test_timedelta_tolerance_nearest(self): expected["time"] = pd.to_timedelta(expected["time"], "ms") - result = pd.merge_asof( + result = merge_asof( left, right, on="time", tolerance=Timedelta("1ms"), direction="nearest" ) @@ -1323,7 +1321,7 @@ def test_int_type_tolerance(self, any_int_dtype): ) expected["a"] = expected["a"].astype(any_int_dtype) - result = pd.merge_asof(left, right, on="a", tolerance=10) + result = merge_asof(left, right, on="a", tolerance=10) tm.assert_frame_equal(result, expected) def test_merge_index_column_tz(self): @@ -1331,7 +1329,7 @@ def test_merge_index_column_tz(self): index = pd.date_range("2019-10-01", freq="30min", periods=5, tz="UTC") left = pd.DataFrame([0.9, 0.8, 0.7, 0.6], columns=["xyz"], index=index[1:]) right = pd.DataFrame({"from_date": index, "abc": [2.46] * 4 + [2.19]}) - result = pd.merge_asof( + result = merge_asof( left=left, right=right, left_index=True, right_on=["from_date"] ) expected = pd.DataFrame( @@ -1344,7 +1342,7 @@ def test_merge_index_column_tz(self): ) tm.assert_frame_equal(result, expected) - result = pd.merge_asof( + result = merge_asof( left=right, right=left, right_index=True, left_on=["from_date"] ) expected = pd.DataFrame( @@ -1370,7 +1368,7 @@ def test_left_index_right_index_tolerance(self): expected = pd.DataFrame( {"val1": "foo", "val2": "bar"}, index=pd.DatetimeIndex(dr1) ) - result = pd.merge_asof( + result = merge_asof( df1, df2, left_index=True, @@ -1395,7 +1393,7 @@ def test_merge_asof_non_numerical_dtype(kwargs, data): MergeError, match=r"Incompatible merge dtype, .*, both sides must have numeric dtype", ): - pd.merge_asof(left, right, **kwargs) + merge_asof(left, right, **kwargs) def test_merge_asof_non_numerical_dtype_object(): @@ -1406,7 +1404,7 @@ def test_merge_asof_non_numerical_dtype_object(): MergeError, match=r"Incompatible merge dtype, .*, both sides must have numeric dtype", ): - pd.merge_asof( + merge_asof( left, right, left_on="left_val1", diff --git a/pandas/tests/reshape/merge/test_multi.py b/pandas/tests/reshape/merge/test_multi.py index 56ea3c9718a41..d9143549e127d 100644 --- a/pandas/tests/reshape/merge/test_multi.py +++ b/pandas/tests/reshape/merge/test_multi.py @@ -112,7 +112,7 @@ def test_merge_on_multikey(self, left, right, join_type): on_cols = ["key1", "key2"] result = left.join(right, on=on_cols, how=join_type).reset_index(drop=True) - expected = pd.merge(left, right.reset_index(), on=on_cols, how=join_type) + expected = merge(left, right.reset_index(), on=on_cols, how=join_type) tm.assert_frame_equal(result, expected) @@ -120,7 +120,7 @@ def test_merge_on_multikey(self, left, right, join_type): drop=True ) - expected = pd.merge( + expected = merge( left, right.reset_index(), on=on_cols, how=join_type, sort=True ) @@ -200,13 +200,13 @@ def test_merge_right_vs_left(self, left, right, sort): def test_merge_multiple_cols_with_mixed_cols_index(self): # GH29522 - s = pd.Series( + s = Series( range(6), MultiIndex.from_product([["A", "B"], [1, 2, 3]], names=["lev1", "lev2"]), name="Amount", ) df = DataFrame({"lev1": list("AAABBB"), "lev2": [1, 2, 3, 1, 2, 3], "col": 0}) - result = pd.merge(df, s.reset_index(), on=["lev1", "lev2"]) + result = merge(df, s.reset_index(), on=["lev1", "lev2"]) expected = DataFrame( { "lev1": list("AAABBB"), @@ -840,7 +840,7 @@ def test_join_multi_multi( ): # Multi-index join tests expected = ( - pd.merge( + merge( left_multi.reset_index(), right_multi.reset_index(), how=join_type, @@ -861,7 +861,7 @@ def test_join_multi_empty_frames( right_multi = right_multi.drop(columns=right_multi.columns) expected = ( - pd.merge( + merge( left_multi.reset_index(), right_multi.reset_index(), how=join_type, @@ -917,7 +917,7 @@ def test_single_common_level(self): ) result = left.join(right) - expected = pd.merge( + expected = merge( left.reset_index(), right.reset_index(), on=["key"], how="inner" ).set_index(["key", "X", "Y"]) diff --git a/pandas/tests/reshape/test_cut.py b/pandas/tests/reshape/test_cut.py index 56326dd15bd9b..06159cf70b1ab 100644 --- a/pandas/tests/reshape/test_cut.py +++ b/pandas/tests/reshape/test_cut.py @@ -681,7 +681,7 @@ def test_cut_unordered_with_series_labels(): s = Series([1, 2, 3, 4, 5]) bins = Series([0, 2, 4, 6]) labels = Series(["a", "b", "c"]) - result = pd.cut(s, bins=bins, labels=labels, ordered=False) + result = cut(s, bins=bins, labels=labels, ordered=False) expected = Series(["a", "a", "b", "b", "c"], dtype="category") tm.assert_series_equal(result, expected) @@ -690,4 +690,4 @@ def test_cut_no_warnings(): df = DataFrame({"value": np.random.randint(0, 100, 20)}) labels = [f"{i} - {i + 9}" for i in range(0, 100, 10)] with tm.assert_produces_warning(False): - df["group"] = pd.cut(df.value, range(0, 105, 10), right=False, labels=labels) + df["group"] = cut(df.value, range(0, 105, 10), right=False, labels=labels) diff --git a/pandas/tests/reshape/test_melt.py b/pandas/tests/reshape/test_melt.py index 53244569d0432..a950c648838ff 100644 --- a/pandas/tests/reshape/test_melt.py +++ b/pandas/tests/reshape/test_melt.py @@ -302,7 +302,7 @@ def test_pandas_dtypes(self, col): def test_preserve_category(self): # GH 15853 data = DataFrame({"A": [1, 2], "B": pd.Categorical(["X", "Y"])}) - result = pd.melt(data, ["B"], ["A"]) + result = melt(data, ["B"], ["A"]) expected = DataFrame( {"B": pd.Categorical(["X", "Y"]), "variable": ["A", "A"], "value": [1, 2]} ) @@ -668,7 +668,7 @@ def test_stubs(self): stubs = ["inc", "edu"] # TODO: unused? - df_long = pd.wide_to_long(df, stubs, i="id", j="age") # noqa + df_long = wide_to_long(df, stubs, i="id", j="age") # noqa assert stubs == ["inc", "edu"] @@ -1055,10 +1055,8 @@ def test_col_substring_of_stubname(self): "PA3": {0: 0.34, 1: 0.70, 2: 0.52, 3: 0.98, 4: 0.67}, } wide_df = DataFrame.from_dict(wide_data) - expected = pd.wide_to_long( - wide_df, stubnames=["PA"], i=["node_id", "A"], j="time" - ) - result = pd.wide_to_long(wide_df, stubnames="PA", i=["node_id", "A"], j="time") + expected = wide_to_long(wide_df, stubnames=["PA"], i=["node_id", "A"], j="time") + result = wide_to_long(wide_df, stubnames="PA", i=["node_id", "A"], j="time") tm.assert_frame_equal(result, expected) def test_warn_of_column_name_value(self): diff --git a/pandas/tests/reshape/test_pivot.py b/pandas/tests/reshape/test_pivot.py index 131fb14d0bf85..e345f4f4b5f7f 100644 --- a/pandas/tests/reshape/test_pivot.py +++ b/pandas/tests/reshape/test_pivot.py @@ -197,7 +197,7 @@ def test_pivot_table_categorical(self): ["c", "d", "c", "d"], categories=["c", "d", "y"], ordered=True ) df = DataFrame({"A": cat1, "B": cat2, "values": [1, 2, 3, 4]}) - result = pd.pivot_table(df, values="values", index=["A", "B"], dropna=True) + result = pivot_table(df, values="values", index=["A", "B"], dropna=True) exp_index = MultiIndex.from_arrays([cat1, cat2], names=["A", "B"]) expected = DataFrame({"values": [1, 2, 3, 4]}, index=exp_index) @@ -302,7 +302,7 @@ def test_pivot_with_interval_index_margins(self): } ) - pivot_tab = pd.pivot_table( + pivot_tab = pivot_table( df, index="C", columns="B", values="A", aggfunc="sum", margins=True ) @@ -409,7 +409,7 @@ def test_pivot_no_values(self): df = DataFrame( { "A": [1, 2, 3, 4, 5], - "dt": pd.date_range("2011-01-01", freq="D", periods=5), + "dt": date_range("2011-01-01", freq="D", periods=5), }, index=idx, ) @@ -492,7 +492,7 @@ def test_pivot_index_with_nan(self, method): # GH9491 df = DataFrame( { - "a": pd.date_range("2014-02-01", periods=6, freq="D"), + "a": date_range("2014-02-01", periods=6, freq="D"), "c": 100 + np.arange(6), } ) @@ -605,7 +605,7 @@ def test_pivot_tz_in_values(self): df = df.set_index("ts").reset_index() mins = df.ts.map(lambda x: x.replace(hour=0, minute=0, second=0, microsecond=0)) - result = pd.pivot_table( + result = pivot_table( df.set_index("ts").reset_index(), values="ts", index=["uid"], @@ -1101,7 +1101,7 @@ def test_pivot_columns_lexsorted(self): iproduct = np.random.randint(0, len(products), n) items["Index"] = products["Index"][iproduct] items["Symbol"] = products["Symbol"][iproduct] - dr = pd.date_range(date(2000, 1, 1), date(2010, 12, 31)) + dr = date_range(date(2000, 1, 1), date(2010, 12, 31)) dates = dr[np.random.randint(0, len(dr), n)] items["Year"] = dates.year items["Month"] = dates.month @@ -1664,17 +1664,17 @@ def test_pivot_table_with_iterator_values(self): # GH 12017 aggs = {"D": "sum", "E": "mean"} - pivot_values_list = pd.pivot_table( + pivot_values_list = pivot_table( self.data, index=["A"], values=list(aggs.keys()), aggfunc=aggs ) - pivot_values_keys = pd.pivot_table( + pivot_values_keys = pivot_table( self.data, index=["A"], values=aggs.keys(), aggfunc=aggs ) tm.assert_frame_equal(pivot_values_keys, pivot_values_list) agg_values_gen = (value for value in aggs.keys()) - pivot_values_gen = pd.pivot_table( + pivot_values_gen = pivot_table( self.data, index=["A"], values=agg_values_gen, aggfunc=aggs ) tm.assert_frame_equal(pivot_values_gen, pivot_values_list) @@ -1749,7 +1749,7 @@ def test_margins_casted_to_float(self, observed): } ) - result = pd.pivot_table(df, index="D", margins=True) + result = pivot_table(df, index="D", margins=True) expected = DataFrame( {"A": [3, 7, 5], "B": [2.5, 6.5, 4.5], "C": [2, 5, 3.5]}, index=Index(["X", "Y", "All"], name="D"), @@ -1887,7 +1887,7 @@ def test_pivot_margins_name_unicode(self): # issue #13292 greek = "\u0394\u03bf\u03ba\u03b9\u03bc\u03ae" frame = DataFrame({"foo": [1, 2, 3]}) - table = pd.pivot_table( + table = pivot_table( frame, index=["foo"], aggfunc=len, margins=True, margins_name=greek ) index = Index([1, 2, 3, greek], dtype="object", name="foo") @@ -2006,7 +2006,7 @@ def ret_sum(x): def ret_none(x): return np.nan - result = pd.pivot_table( + result = pivot_table( df, columns="fruit", aggfunc=[ret_sum, ret_none, ret_one], dropna=dropna ) @@ -2028,7 +2028,7 @@ def test_pivot_table_aggfunc_scalar_dropna(self, dropna): {"A": ["one", "two", "one"], "x": [3, np.nan, 2], "y": [1, np.nan, np.nan]} ) - result = pd.pivot_table(df, columns="A", aggfunc=np.mean, dropna=dropna) + result = pivot_table(df, columns="A", aggfunc=np.mean, dropna=dropna) data = [[2.5, np.nan], [1, np.nan]] col = Index(["one", "two"], name="A")