REF: method-specific test files for Series/DataFrame (#30414)

Author: jbrockmendel

pandas/tests/frame/methods/test_diff.py

@@ -0,0 +1,120 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import DataFrame, Series, Timestamp, date_range
+import pandas.util.testing as tm
+
+
+class TestDataFrameDiff:
+    def test_diff(self, datetime_frame):
+        the_diff = datetime_frame.diff(1)
+
+        tm.assert_series_equal(
+            the_diff["A"], datetime_frame["A"] - datetime_frame["A"].shift(1)
+        )
+
+        # int dtype
+        a = 10000000000000000
+        b = a + 1
+        s = Series([a, b])
+
+        rs = DataFrame({"s": s}).diff()
+        assert rs.s[1] == 1
+
+        # mixed numeric
+        tf = datetime_frame.astype("float32")
+        the_diff = tf.diff(1)
+        tm.assert_series_equal(the_diff["A"], tf["A"] - tf["A"].shift(1))
+
+        # GH#10907
+        df = pd.DataFrame({"y": pd.Series([2]), "z": pd.Series([3])})
+        df.insert(0, "x", 1)
+        result = df.diff(axis=1)
+        expected = pd.DataFrame(
+            {"x": np.nan, "y": pd.Series(1), "z": pd.Series(1)}
+        ).astype("float64")
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("tz", [None, "UTC"])
+    def test_diff_datetime_axis0(self, tz):
+        # GH#18578
+        df = DataFrame(
+            {
+                0: date_range("2010", freq="D", periods=2, tz=tz),
+                1: date_range("2010", freq="D", periods=2, tz=tz),
+            }
+        )
+
+        result = df.diff(axis=0)
+        expected = DataFrame(
+            {
+                0: pd.TimedeltaIndex(["NaT", "1 days"]),
+                1: pd.TimedeltaIndex(["NaT", "1 days"]),
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+    @pytest.mark.parametrize("tz", [None, "UTC"])
+    def test_diff_datetime_axis1(self, tz):
+        # GH#18578
+        df = DataFrame(
+            {
+                0: date_range("2010", freq="D", periods=2, tz=tz),
+                1: date_range("2010", freq="D", periods=2, tz=tz),
+            }
+        )
+        if tz is None:
+            result = df.diff(axis=1)
+            expected = DataFrame(
+                {
+                    0: pd.TimedeltaIndex(["NaT", "NaT"]),
+                    1: pd.TimedeltaIndex(["0 days", "0 days"]),
+                }
+            )
+            tm.assert_frame_equal(result, expected)
+        else:
+            with pytest.raises(NotImplementedError):
+                result = df.diff(axis=1)
+
+    def test_diff_timedelta(self):
+        # GH#4533
+        df = DataFrame(
+            dict(
+                time=[Timestamp("20130101 9:01"), Timestamp("20130101 9:02")],
+                value=[1.0, 2.0],
+            )
+        )
+
+        res = df.diff()
+        exp = DataFrame(
+            [[pd.NaT, np.nan], [pd.Timedelta("00:01:00"), 1]], columns=["time", "value"]
+        )
+        tm.assert_frame_equal(res, exp)
+
+    def test_diff_mixed_dtype(self):
+        df = DataFrame(np.random.randn(5, 3))
+        df["A"] = np.array([1, 2, 3, 4, 5], dtype=object)
+
+        result = df.diff()
+        assert result[0].dtype == np.float64
+
+    def test_diff_neg_n(self, datetime_frame):
+        rs = datetime_frame.diff(-1)
+        xp = datetime_frame - datetime_frame.shift(-1)
+        tm.assert_frame_equal(rs, xp)
+
+    def test_diff_float_n(self, datetime_frame):
+        rs = datetime_frame.diff(1.0)
+        xp = datetime_frame.diff(1)
+        tm.assert_frame_equal(rs, xp)
+
+    def test_diff_axis(self):
+        # GH#9727
+        df = DataFrame([[1.0, 2.0], [3.0, 4.0]])
+        tm.assert_frame_equal(
+            df.diff(axis=1), DataFrame([[np.nan, 1.0], [np.nan, 1.0]])
+        )
+        tm.assert_frame_equal(
+            df.diff(axis=0), DataFrame([[np.nan, np.nan], [2.0, 2.0]])
+        )

pandas/tests/frame/methods/test_shift.py

@@ -0,0 +1,187 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import DataFrame, Index, Series, date_range, offsets
+import pandas.util.testing as tm
+
+
+class TestDataFrameShift:
+    def test_shift(self, datetime_frame, int_frame):
+        # naive shift
+        shiftedFrame = datetime_frame.shift(5)
+        tm.assert_index_equal(shiftedFrame.index, datetime_frame.index)
+
+        shiftedSeries = datetime_frame["A"].shift(5)
+        tm.assert_series_equal(shiftedFrame["A"], shiftedSeries)
+
+        shiftedFrame = datetime_frame.shift(-5)
+        tm.assert_index_equal(shiftedFrame.index, datetime_frame.index)
+
+        shiftedSeries = datetime_frame["A"].shift(-5)
+        tm.assert_series_equal(shiftedFrame["A"], shiftedSeries)
+
+        # shift by 0
+        unshifted = datetime_frame.shift(0)
+        tm.assert_frame_equal(unshifted, datetime_frame)
+
+        # shift by DateOffset
+        shiftedFrame = datetime_frame.shift(5, freq=offsets.BDay())
+        assert len(shiftedFrame) == len(datetime_frame)
+
+        shiftedFrame2 = datetime_frame.shift(5, freq="B")
+        tm.assert_frame_equal(shiftedFrame, shiftedFrame2)
+
+        d = datetime_frame.index[0]
+        shifted_d = d + offsets.BDay(5)
+        tm.assert_series_equal(
+            datetime_frame.xs(d), shiftedFrame.xs(shifted_d), check_names=False
+        )
+
+        # shift int frame
+        int_shifted = int_frame.shift(1)  # noqa
+
+        # Shifting with PeriodIndex
+        ps = tm.makePeriodFrame()
+        shifted = ps.shift(1)
+        unshifted = shifted.shift(-1)
+        tm.assert_index_equal(shifted.index, ps.index)
+        tm.assert_index_equal(unshifted.index, ps.index)
+        tm.assert_numpy_array_equal(
+            unshifted.iloc[:, 0].dropna().values, ps.iloc[:-1, 0].values
+        )
+
+        shifted2 = ps.shift(1, "B")
+        shifted3 = ps.shift(1, offsets.BDay())
+        tm.assert_frame_equal(shifted2, shifted3)
+        tm.assert_frame_equal(ps, shifted2.shift(-1, "B"))
+
+        msg = "does not match PeriodIndex freq"
+        with pytest.raises(ValueError, match=msg):
+            ps.shift(freq="D")
+
+        # shift other axis
+        # GH#6371
+        df = DataFrame(np.random.rand(10, 5))
+        expected = pd.concat(
+            [DataFrame(np.nan, index=df.index, columns=[0]), df.iloc[:, 0:-1]],
+            ignore_index=True,
+            axis=1,
+        )
+        result = df.shift(1, axis=1)
+        tm.assert_frame_equal(result, expected)
+
+        # shift named axis
+        df = DataFrame(np.random.rand(10, 5))
+        expected = pd.concat(
+            [DataFrame(np.nan, index=df.index, columns=[0]), df.iloc[:, 0:-1]],
+            ignore_index=True,
+            axis=1,
+        )
+        result = df.shift(1, axis="columns")
+        tm.assert_frame_equal(result, expected)
+
+    def test_shift_bool(self):
+        df = DataFrame({"high": [True, False], "low": [False, False]})
+        rs = df.shift(1)
+        xp = DataFrame(
+            np.array([[np.nan, np.nan], [True, False]], dtype=object),
+            columns=["high", "low"],
+        )
+        tm.assert_frame_equal(rs, xp)
+
+    def test_shift_categorical(self):
+        # GH#9416
+        s1 = pd.Series(["a", "b", "c"], dtype="category")
+        s2 = pd.Series(["A", "B", "C"], dtype="category")
+        df = DataFrame({"one": s1, "two": s2})
+        rs = df.shift(1)
+        xp = DataFrame({"one": s1.shift(1), "two": s2.shift(1)})
+        tm.assert_frame_equal(rs, xp)
+
+    def test_shift_fill_value(self):
+        # GH#24128
+        df = DataFrame(
+            [1, 2, 3, 4, 5], index=date_range("1/1/2000", periods=5, freq="H")
+        )
+        exp = DataFrame(
+            [0, 1, 2, 3, 4], index=date_range("1/1/2000", periods=5, freq="H")
+        )
+        result = df.shift(1, fill_value=0)
+        tm.assert_frame_equal(result, exp)
+
+        exp = DataFrame(
+            [0, 0, 1, 2, 3], index=date_range("1/1/2000", periods=5, freq="H")
+        )
+        result = df.shift(2, fill_value=0)
+        tm.assert_frame_equal(result, exp)
+
+    def test_shift_empty(self):
+        # Regression test for GH#8019
+        df = DataFrame({"foo": []})
+        rs = df.shift(-1)
+
+        tm.assert_frame_equal(df, rs)
+
+    def test_shift_duplicate_columns(self):
+        # GH#9092; verify that position-based shifting works
+        # in the presence of duplicate columns
+        column_lists = [list(range(5)), [1] * 5, [1, 1, 2, 2, 1]]
+        data = np.random.randn(20, 5)
+
+        shifted = []
+        for columns in column_lists:
+            df = pd.DataFrame(data.copy(), columns=columns)
+            for s in range(5):
+                df.iloc[:, s] = df.iloc[:, s].shift(s + 1)
+            df.columns = range(5)
+            shifted.append(df)
+
+        # sanity check the base case
+        nulls = shifted[0].isna().sum()
+        tm.assert_series_equal(nulls, Series(range(1, 6), dtype="int64"))
+
+        # check all answers are the same
+        tm.assert_frame_equal(shifted[0], shifted[1])
+        tm.assert_frame_equal(shifted[0], shifted[2])
+
+    def test_tshift(self, datetime_frame):
+        # PeriodIndex
+        ps = tm.makePeriodFrame()
+        shifted = ps.tshift(1)
+        unshifted = shifted.tshift(-1)
+
+        tm.assert_frame_equal(unshifted, ps)
+
+        shifted2 = ps.tshift(freq="B")
+        tm.assert_frame_equal(shifted, shifted2)
+
+        shifted3 = ps.tshift(freq=offsets.BDay())
+        tm.assert_frame_equal(shifted, shifted3)
+
+        with pytest.raises(ValueError, match="does not match"):
+            ps.tshift(freq="M")
+
+        # DatetimeIndex
+        shifted = datetime_frame.tshift(1)
+        unshifted = shifted.tshift(-1)
+
+        tm.assert_frame_equal(datetime_frame, unshifted)
+
+        shifted2 = datetime_frame.tshift(freq=datetime_frame.index.freq)
+        tm.assert_frame_equal(shifted, shifted2)
+
+        inferred_ts = DataFrame(
+            datetime_frame.values,
+            Index(np.asarray(datetime_frame.index)),
+            columns=datetime_frame.columns,
+        )
+        shifted = inferred_ts.tshift(1)
+        unshifted = shifted.tshift(-1)
+        tm.assert_frame_equal(shifted, datetime_frame.tshift(1))
+        tm.assert_frame_equal(unshifted, inferred_ts)
+
+        no_freq = datetime_frame.iloc[[0, 5, 7], :]
+        msg = "Freq was not given and was not set in the index"
+        with pytest.raises(ValueError, match=msg):
+            no_freq.tshift()