ENH: Allow column grouping in DataFrame.plot

doc/source/whatsnew/v1.1.0.rst

@@ -340,6 +340,9 @@ Other enhancements
 - :meth:`DataFrame.agg` and :meth:`Series.agg` now accept named aggregation for renaming the output columns/indexes. (:issue:`26513`)
 - ``compute.use_numba`` now exists as a configuration option that utilizes the numba engine when available (:issue:`33966`)
 - :meth:`Series.plot` now supports asymmetric error bars. Previously, if :meth:`Series.plot` received a "2xN" array with error values for `yerr` and/or `xerr`, the left/lower values (first row) were mirrored, while the right/upper values (second row) were ignored. Now, the first row represents the left/lower error values and the second row the right/upper error values. (:issue:`9536`)
+- :meth:`DataFrame.plot` will now allow the ``subplots`` parameter to be
+  a list of iterables specifying column groups, so that columns may be
+  grouped together in the same subplot (:issue:`29688`).
 
 .. ---------------------------------------------------------------------------
 

pandas/plotting/_core.py

@@ -636,8 +636,15 @@ class PlotAccessor(PandasObject):
         - 'hexbin' : hexbin plot.
     ax : matplotlib axes object, default None
         An axes of the current figure.
-    subplots : bool, default False
-        Make separate subplots for each column.
+    subplots : bool or list of iterables, default False
+
+        - ``False`` - no subplots will be used
+        - ``True`` - Make separate subplots for each column.
+        - ``sequence of sequences of str`` - create a subplot for each group of columns.
+          For example `[('a', 'c'), ('b', 'd')]` will create 2 subplots: one
+          with columns 'a' and 'c', and one with columns 'b' and 'd'.
+          Remaining columns that aren't specified will be plotted in
+          additional subplots (one per column).
     sharex : bool, default True if ax is None else False
         In case ``subplots=True``, share x axis and set some x axis labels
         to invisible; defaults to True if ax is None otherwise False if

pandas/plotting/_matplotlib/core.py

@@ -1,5 +1,6 @@
+from collections import Counter, Iterable
 import re
-from typing import List, Optional
+from typing import List, Optional, Sequence, Union
 import warnings
 
 from matplotlib.artist import Artist
@@ -84,7 +85,7 @@ def __init__(
         data,
         kind=None,
         by=None,
-        subplots=False,
+        subplots: Union[bool, Sequence[Sequence[str]]] = False,
         sharex=None,
         sharey=False,
         use_index=True,
@@ -119,8 +120,7 @@ def __init__(
         self.kind = kind
 
         self.sort_columns = sort_columns
-
-        self.subplots = subplots
+        self.subplots = self._validate_subplots_kwarg(subplots)
 
         if sharex is None:
             if ax is None:
@@ -200,6 +200,79 @@ def __init__(
 
         self._validate_color_args()
 
+    def _validate_subplots_kwarg(
+        self, subplots: Union[bool, Sequence[Sequence[str]]]
+    ) -> Union[bool, Sequence[Sequence[int]]]:
+
+        if isinstance(subplots, bool):
+            return subplots
+        elif not isinstance(subplots, Iterable):
+            raise ValueError("subplots should be a bool or an iterable")
+
+        supported_kinds = (
+            "line",
+            "bar",
+            "barh",
+            "hist",
+            "kde",
+            "density",
+            "area",
+            "pie",
+        )
+        if self._kind not in supported_kinds:
+            raise ValueError(
+                "When subplots is an iterable, kind must be "
+                f"one of {', '.join(supported_kinds)}. Got {self._kind}."
+            )
+
+        if any(
+            not isinstance(group, Iterable) or isinstance(group, str)
+            for group in subplots
+        ):
+            raise ValueError(
+                "When subplots is an iterable, each entry "
+                "should be a list/tuple of column names."
+            )
+
+        cols_in_groups = [col for group in subplots for col in group]
+        duplicates = {col for (col, cnt) in Counter(cols_in_groups).items() if cnt > 1}
+        if duplicates:
+            raise ValueError(
+                f"Each column should be in only one subplot. Columns {duplicates} "
+                "were found in multiple sublots."
+            )
+
+        cols_in_groups_set = set(cols_in_groups)
+        cols_remaining = set(self.data.columns) - cols_in_groups_set
+        bad_columns = cols_in_groups_set - set(self.data.columns)
+
+        if bad_columns:
+            raise ValueError(
+                "Subplots contains the following column(s) "
+                f"which are invalid names: {bad_columns}"
+            )
+
+        # subplots is a list of tuples where each tuple is a group of
+        # columns to be grouped together (one ax per group).
+        # we consolidate the subplots list such that:
+        # - the tuples contain indices instead of column names
+        # - the columns that aren't yet in the list are added in a group
+        #   of their own.
+        # For example with columns from a to g, and
+        # subplots = [(a, c), (b, f, e)],
+        # we end up with [(ai, ci), (bi, fi, ei), (di,), (gi,)]
+        # This way, we can handle self.subplots in a homogeneous manner
+        # later.
+        # TODO: also accept indices instead of just names?
+
+        out = []
+        index = list(self.data.columns).index
+        for group in subplots:
+            out.append(tuple(index(col) for col in group))
+        for col in cols_remaining:
+            out.append((index(col),))
+        return out
+
     def _validate_color_args(self):
         import matplotlib.colors
 
@@ -314,8 +387,11 @@ def _maybe_right_yaxis(self, ax, axes_num):
 
     def _setup_subplots(self):
         if self.subplots:
+            naxes = (
+                self.nseries if isinstance(self.subplots, bool) else len(self.subplots)
+            )
             fig, axes = _subplots(
-                naxes=self.nseries,
+                naxes=naxes,
                 sharex=self.sharex,
                 sharey=self.sharey,
                 figsize=self.figsize,
@@ -693,9 +769,21 @@ def _get_ax_layer(cls, ax, primary=True):
         else:
             return getattr(ax, "right_ax", ax)
 
+    def _col_idx_to_axis_idx(self, col_idx: int):
+        """Return the index of the axis where the column at col_idx should be plotted"""
+        if isinstance(self.subplots, list):
+            # Subplots is a list: some columns will be grouped together in the same ax
+            for group_idx, group in enumerate(self.subplots):
+                if col_idx in group:
+                    return group_idx
+        else:
+            # subplots is True: one ax per column
+            return col_idx
+
     def _get_ax(self, i):
         # get the twinx ax if appropriate
         if self.subplots:
+            i = self._col_idx_to_axis_idx(i)
             ax = self.axes[i]
             ax = self._maybe_right_yaxis(ax, i)
             self.axes[i] = ax

pandas/tests/plotting/test_frame.py

@@ -409,6 +409,9 @@ def test_subplots(self):
             for ax in axes:
                 assert ax.get_legend() is None
 
+        with pytest.raises(ValueError, match="should be a bool or an iterable"):
+            axes = df.plot(subplots=123)
+
     def test_groupby_boxplot_sharey(self):
         # https://github.com/pandas-dev/pandas/issues/20968
         # sharey can now be switched check whether the right
@@ -3325,6 +3328,71 @@ def test_plot_no_numeric_data(self):
         with pytest.raises(TypeError):
             df.plot()
 
+    @td.skip_if_no_scipy
+    @pytest.mark.parametrize(
+        "kind", ("line", "bar", "barh", "hist", "kde", "density", "area", "pie")
+    )
+    def test_group_subplot(self, kind):
+        d = {
+            "a": np.arange(10),
+            "b": np.arange(10) + 1,
+            "c": np.arange(10) + 1,
+            "d": np.arange(10),
+            "e": np.arange(10),
+        }
+        df = pd.DataFrame(d)
+
+        axes = df.plot(subplots=[("b", "e"), ("c", "d")], kind=kind)
+        assert len(axes) == 3  # 2 groups + single column a
+
+        expected_labels = (["b", "e"], ["c", "d"], ["a"])
+        for ax, labels in zip(axes, expected_labels):
+            if kind != "pie":
+                self._check_legend_labels(ax, labels=labels)
+            if kind == "line":
+                assert len(ax.lines) == len(labels)
+
+    @pytest.mark.parametrize(
+        "subplots",
+        [
+            "a",  # iterable of non-iterable
+            (1,),  # iterable of non-iterable
+            ("a",),  # iterable of strings
+        ],
+    )
+    def test_group_subplot_bad_input(self, subplots):
+        # Make sure error is raised when subplots is not a properly
+        # formatted iterable. Only iterables of iterables are permitted, and
+        # entries should not be strings.
+        d = {"a": np.arange(10), "b": np.arange(10)}
+        df = pd.DataFrame(d)
+
+        with pytest.raises(ValueError, match="each entry should be a list/tuple"):
+            df.plot(subplots=subplots)
+
+    def test_group_subplot_invalid_column_name(self):
+        d = {"a": np.arange(10), "b": np.arange(10)}
+        df = pd.DataFrame(d)
+
+        with pytest.raises(ValueError, match="invalid names: {'bad_name'}"):
+            df.plot(subplots=[("a", "bad_name")])
+
+    def test_group_subplot_duplicated_column(self):
+        d = {"a": np.arange(10), "b": np.arange(10), "c": np.arange(10)}
+        df = pd.DataFrame(d)
+
+        with pytest.raises(ValueError, match="should be in only one subplot"):
+            df.plot(subplots=[("a", "b"), ("a", "c")])
+
+    @pytest.mark.parametrize("kind", ("box", "scatter", "hexbin"))
+    def test_group_subplot_invalid_kind(self, kind):
+        d = {"a": np.arange(10), "b": np.arange(10)}
+        df = pd.DataFrame(d)
+        with pytest.raises(
+            ValueError, match="When subplots is an iterable, kind must be one of"
+        ):
+            df.plot(subplots=[("a", "b")], kind=kind)
+
     def test_missing_markers_legend(self):
         # 14958
         df = pd.DataFrame(np.random.randn(8, 3), columns=["A", "B", "C"])