Initial implementation of rolling iterators

doc/source/whatsnew/v0.25.0.rst

@@ -1141,6 +1141,7 @@ Groupby/resample/rolling
 - Improved :class:`pandas.core.window.Rolling`, :class:`pandas.core.window.Window` and :class:`pandas.core.window.EWM` functions to exclude nuisance columns from results instead of raising errors and raise a ``DataError`` only if all columns are nuisance (:issue:`12537`)
 - Bug in :meth:`pandas.core.window.Rolling.max` and :meth:`pandas.core.window.Rolling.min` where incorrect results are returned with an empty variable window (:issue:`26005`)
 - Raise a helpful exception when an unsupported weighted window function is used as an argument of :meth:`pandas.core.window.Window.aggregate` (:issue:`26597`)
+- Improved :class:`pandas.core.window.Rolling` and :class:`pandas.core.window.Window` it is now possible to iterate over a window object (:issue:`12537`)
 
 Reshaping
 ^^^^^^^^^

pandas/core/window.py

@@ -204,8 +204,47 @@ def __repr__(self):
         )
 
     def __iter__(self):
-        url = "https://github.com/pandas-dev/pandas/issues/11704"
-        raise NotImplementedError("See issue #11704 {url}".format(url=url))
+        closed = self.closed
+        window = self._get_window()
+        minp = _use_window(self.min_periods, window)
+        offset = _offset(window, self.center)
+
+        blocks, obj, index = self._create_blocks()
+        _, indexi = self._get_index(index)
+
+        for values in blocks:
+            arr = np.asarray(values)
+
+            start, end, N, win, _minp, is_variable = libwindow.get_window_indexer(
+                arr, window, minp, indexi, closed
+            )
+
+            if arr.ndim == 1:
+                arr = np.expand_dims(arr, axis=1)
+
+            counts = libwindow.roll_sum(
+                np.concatenate(
+                    [
+                        np.isfinite(arr).all(axis=1).astype(float),
+                        np.array([0.0] * offset),
+                    ]
+                ),
+                win,
+                minp,
+                index,
+                closed,
+            )[offset:]
+
+            for i in range(N):
+                if counts[i] >= _minp:
+                    if is_variable:
+                        s = start[i]
+                        e = end[i]
+                    else:
+                        s = max(i - win + offset + 1, 0)
+                        e = min(i + offset + 1, N)
+
+                    yield values.iloc[slice(s, e)]
 
     def _get_index(self, index=None):
         """

pandas/tests/window/test_expanding.py

@@ -90,13 +90,62 @@ def test_missing_minp_zero(self):
         expected = pd.Series([np.nan])
         tm.assert_series_equal(result, expected)
 
-    @pytest.mark.parametrize("klass", [pd.Series, pd.DataFrame])
-    def test_iter_raises(self, klass):
-        # https://github.com/pandas-dev/pandas/issues/11704
-        # Iteration over a Window
-        obj = klass([1, 2, 3, 4])
-        with pytest.raises(NotImplementedError):
-            iter(obj.expanding(2))
+    @pytest.mark.parametrize(
+        "dataframe,expected,window",
+        [
+            (
+                DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}),
+                [({"A": [1, 2, 3], "B": [4, 5, 6]}, [0, 1, 2])],
+                3,
+            ),
+            (
+                DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}),
+                [
+                    ({"A": [1, 2], "B": [4, 5]}, [0, 1]),
+                    ({"A": [1, 2, 3], "B": [4, 5, 6]}, [0, 1, 2]),
+                ],
+                2,
+            ),
+            (
+                DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}),
+                [
+                    ({"A": [1], "B": [4]}, [0]),
+                    ({"A": [1, 2], "B": [4, 5]}, [0, 1]),
+                    ({"A": [1, 2, 3], "B": [4, 5, 6]}, [0, 1, 2]),
+                ],
+                1,
+            ),
+            (DataFrame({"A": [1], "B": [4]}), [], 1337),
+            (DataFrame(), [({}, [])], 1337),
+        ],
+    )
+    def test_iterator_dataframe(self, dataframe, expected, window):
+        expected = [DataFrame(values, index=index) for (values, index) in expected]
+
+        for (expected, actual) in zip(
+            expected, dataframe.expanding(min_periods=window)
+        ):
+            tm.assert_frame_equal(actual, expected)
+
+    @pytest.mark.parametrize(
+        "series,expected,window",
+        [
+            (Series([1, 2, 3]), [([1, 2, 3], [0, 1, 2])], 3),
+            (Series([1, 2, 3]), [([1, 2], [0, 1]), ([1, 2, 3], [0, 1, 2])], 2),
+            (
+                Series([1, 2, 3]),
+                [([1], [0]), ([1, 2], [0, 1]), ([1, 2, 3], [0, 1, 2])],
+                1,
+            ),
+            (Series([1, 2]), [([1, 2], [0, 1])], 1337),
+            (Series([]), [], 1337),
+        ],
+    )
+    def test_iterator_series(self, series, expected, window):
+        expected = [Series(values, index=index) for (values, index) in expected]
+
+        for (expected, actual) in zip(expected, series.expanding(min_periods=window)):
+            tm.assert_series_equal(actual, expected)
 
     def test_expanding_axis(self, axis_frame):
         # see gh-23372.

pandas/tests/window/test_rolling.py

@@ -98,6 +98,131 @@ def test_constructor_timedelta_window_and_minperiods(self, window, raw):
         tm.assert_frame_equal(result_roll_sum, expected)
         tm.assert_frame_equal(result_roll_generic, expected)
 
+    @pytest.mark.parametrize(
+        "dataframe,expected,window",
+        [
+            (
+                DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}),
+                [({"A": [1, 2, 3], "B": [4, 5, 6]}, [0, 1, 2])],
+                3,
+            ),
+            (
+                DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}),
+                [
+                    ({"A": [1, 2], "B": [4, 5]}, [0, 1]),
+                    ({"A": [2, 3], "B": [5, 6]}, [1, 2]),
+                ],
+                2,
+            ),
+            (
+                DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}),
+                [
+                    ({"A": [1], "B": [4]}, [0]),
+                    ({"A": [2], "B": [5]}, [1]),
+                    ({"A": [3], "B": [6]}, [2]),
+                ],
+                1,
+            ),
+            (DataFrame({"A": [1], "B": [4]}), [], 1337),
+            (DataFrame(), [({}, [])], 1337),
+        ],
+    )
+    def test_iterator_dataframe(self, dataframe, expected, window):
+        expected = [DataFrame(values, index=index) for (values, index) in expected]
+
+        for (expected, actual) in zip(expected, dataframe.rolling(window)):
+            tm.assert_frame_equal(actual, expected)
+
+    @pytest.mark.parametrize(
+        "series,expected,window",
+        [
+            (Series([1, 2, 3]), [([1, 2, 3], [0, 1, 2])], 3),
+            (Series([1, 2, 3]), [([1, 2], [0, 1]), ([2, 3], [1, 2])], 2),
+            (Series([1, 2, 3]), [([1], [0]), ([2], [1]), ([3], [2])], 1),
+            (Series([1, 2]), [([1, 2], [0, 1])], 1337),
+            (Series([]), [], 1337),
+        ],
+    )
+    def test_iterator_series(self, series, expected, window):
+        expected = [Series(values, index=index) for (values, index) in expected]
+
+        for (expected, actual) in zip(expected, series.rolling(window)):
+            tm.assert_series_equal(actual, expected)
+
+    @pytest.mark.parametrize(
+        "expected,window,minp",
+        [
+            (
+                [
+                    ({"A": [1, 2], "B": [4, 5]}, [0, 1]),
+                    ({"A": [1, 2, 3], "B": [4, 5, 6]}, [0, 1, 2]),
+                ],
+                3,
+                2,
+            ),
+            ([], 3, 4),
+        ],
+    )
+    def test_iterator_dataframe_min_periods(self, expected, window, minp):
+        dataframe = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+
+        expected = [DataFrame(values, index=index) for (values, index) in expected]
+
+        for (expected, actual) in zip(
+            expected, dataframe.rolling(window, min_periods=minp)
+        ):
+            tm.assert_frame_equal(actual, expected)
+
+    @pytest.mark.parametrize(
+        "expected,window,minp",
+        [([([1, 2], [0, 1]), ([1, 2, 3], [0, 1, 2])], 3, 2), ([], 3, 4)],
+    )
+    def test_iterator_series_min_periods(self, expected, window, minp):
+        series = Series([1, 2, 3])
+
+        expected = [Series(values, index=index) for (values, index) in expected]
+
+        for (expected, actual) in zip(
+            expected, series.rolling(window, min_periods=minp)
+        ):
+            tm.assert_series_equal(actual, expected)
+
+    @pytest.mark.parametrize(
+        "expected,window,minp",
+        [
+            ([([1.0, np.nan, 3.0], [0, 1, 2]), ([np.nan, 3.0, 4.0], [1, 2, 3])], 3, 2),
+            ([([1.0, np.nan, 3.0, 4.0], [0, 1, 2, 3])], 4, 3),
+            ([], 4, 4),
+        ],
+    )
+    def test_iterator_series_min_periods_nan(self, expected, window, minp):
+        series = Series([1, np.nan, 3, 4])
+
+        expected = [Series(values, index=index) for (values, index) in expected]
+
+        for (expected, actual) in zip(
+            expected, series.rolling(window, min_periods=minp)
+        ):
+            tm.assert_series_equal(actual, expected)
+
+    @pytest.mark.parametrize(
+        "expected,window,minp",
+        [
+            ([({"A": [1, np.nan, 3], "B": [np.nan, 5, 6]}, [0, 1, 2])], 3, 2),
+            ([], 2, 2),
+            ([], 3, 4),
+        ],
+    )
+    def test_iterator_dataframe_min_periods_nan(self, expected, window, minp):
+        dataframe = DataFrame({"A": [1, np.nan, 3], "B": [np.nan, 5, 6]})
+
+        expected = [DataFrame(values, index=index) for (values, index) in expected]
+
+        for (expected, actual) in zip(
+            expected, dataframe.rolling(window, min_periods=minp)
+        ):
+            tm.assert_frame_equal(actual, expected)
+
     @pytest.mark.parametrize("method", ["std", "mean", "sum", "max", "min", "var"])
     def test_numpy_compat(self, method):
         # see gh-12811
@@ -291,14 +416,6 @@ def test_multi_index_names(self):
         tm.assert_index_equal(result.columns, df.columns)
         assert result.index.names == [None, "1", "2"]
 
-    @pytest.mark.parametrize("klass", [pd.Series, pd.DataFrame])
-    def test_iter_raises(self, klass):
-        # https://github.com/pandas-dev/pandas/issues/11704
-        # Iteration over a Window
-        obj = klass([1, 2, 3, 4])
-        with pytest.raises(NotImplementedError):
-            iter(obj.rolling(2))
-
     def test_rolling_axis_sum(self, axis_frame):
         # see gh-23372.
         df = DataFrame(np.ones((10, 20)))

pandas/tests/window/test_timeseries_window.py

@@ -690,3 +690,82 @@ def test_rolling_cov_offset(self):
 
         expected2 = ss.rolling(3, min_periods=1).cov()
         tm.assert_series_equal(result, expected2)
+
+    @pytest.mark.parametrize(
+        "expected,window",
+        [
+            ([([0], [0]), ([1], [1]), ([2], [2]), ([3], [3]), ([4], [4])], "1s"),
+            (
+                [
+                    ([0], [0]),
+                    ([0, 1], [0, 1]),
+                    ([1, 2], [1, 2]),
+                    ([2, 3], [2, 3]),
+                    ([3, 4], [3, 4]),
+                ],
+                "2S",
+            ),
+            (
+                [
+                    ([0], [0]),
+                    ([0, 1], [0, 1]),
+                    ([0, 1, 2], [0, 1, 2]),
+                    ([1, 2, 3], [1, 2, 3]),
+                    ([2, 3, 4], [2, 3, 4]),
+                ],
+                "3S",
+            ),
+        ],
+    )
+    def test_iterator_series_rolling(self, expected, window):
+        series = Series(
+            range(5), index=date_range(start="2016-01-01 09:30:00", periods=5, freq="s")
+        )
+
+        expected = [
+            Series(values, index=series.index[index]) for (values, index) in expected
+        ]
+
+        for (expected, actual) in zip(expected, series.rolling(window)):
+            tm.assert_series_equal(actual, expected)
+
+    @pytest.mark.parametrize(
+        "expected,window,minp",
+        [
+            ([], "1s", 2),
+            (
+                [
+                    ([0, 1], [0, 1]),
+                    ([1, 2], [1, 2]),
+                    ([2, 3], [2, 3]),
+                    ([3, 4], [3, 4]),
+                ],
+                "2S",
+                2,
+            ),
+            (
+                [
+                    ([0], [0]),
+                    ([0, 1], [0, 1]),
+                    ([0, 1, 2], [0, 1, 2]),
+                    ([1, 2, 3], [1, 2, 3]),
+                    ([2, 3, 4], [2, 3, 4]),
+                ],
+                "3S",
+                1,
+            ),
+        ],
+    )
+    def test_iterator_series_rolling_min_periods(self, expected, window, minp):
+        series = Series(
+            range(5), index=date_range(start="2016-01-01 09:30:00", periods=5, freq="s")
+        )
+
+        expected = [
+            Series(values, index=series.index[index]) for (values, index) in expected
+        ]
+
+        for (expected, actual) in zip(
+            expected, series.rolling(window, min_periods=minp)
+        ):
+            tm.assert_series_equal(actual, expected)