ENH: Added multicolumn/multirow support for latex

- [X] closes pandas-dev#13508
- [X] tests added / passed
- [X] passes `git diff upstream/master | flake8 --diff`
- [X] whatsnew entry

Print names of MultiIndex columns.
Added "multicol" and "multirow" flags to to_latex
which trigger the corresponding feature.
Multirow adds clines to visually separate sections.

Author: sgsaenger

doc/source/whatsnew/v0.20.0.txt

@@ -30,6 +30,7 @@ New features
 Other enhancements
 ^^^^^^^^^^^^^^^^^^
 
+- The ``.to_latex()`` method will now accept ``multicol`` and ``multirow`` arguments to use the accompanying LaTeX enhancements
 
 
 

pandas/core/config_init.py

@@ -249,6 +249,20 @@
     method. Valid values: False,True
 """
 
+pc_latex_multicol = """
+: bool
+    This specifies if the to_latex method of a Dataframe uses multicolumns
+    to pretty-print MultiIndex columns.
+    method. Valid values: False,True
+"""
+
+pc_latex_multirow = """
+: bool
+    This specifies if the to_latex method of a Dataframe uses multirows
+    to pretty-print MultiIndex rows.
+    method. Valid values: False,True
+"""
+
 style_backup = dict()
 
 
@@ -338,6 +352,10 @@ def mpl_style_cb(key):
                        validator=is_bool)
     cf.register_option('latex.longtable', False, pc_latex_longtable,
                        validator=is_bool)
+    cf.register_option('latex.multicol', True, pc_latex_multicol,
+                       validator=is_bool)
+    cf.register_option('latex.multirow', False, pc_latex_multirow,
+                       validator=is_bool)
 
 cf.deprecate_option('display.line_width',
                     msg=pc_line_width_deprecation_warning,

pandas/core/frame.py

@@ -1615,10 +1615,10 @@ def to_latex(self, buf=None, columns=None, col_space=None, header=True,
                  index=True, na_rep='NaN', formatters=None, float_format=None,
                  sparsify=None, index_names=True, bold_rows=True,
                  column_format=None, longtable=None, escape=None,
-                 encoding=None, decimal='.'):
-        """
+                 encoding=None, decimal='.', multicol=None, multirow=None):
+        r"""
         Render a DataFrame to a tabular environment table. You can splice
-        this into a LaTeX document. Requires \\usepackage{booktabs}.
+        this into a LaTeX document. Requires \usepackage{booktabs}.
 
         `to_latex`-specific options:
 
@@ -1631,7 +1631,7 @@ def to_latex(self, buf=None, columns=None, col_space=None, header=True,
         longtable : boolean, default will be read from the pandas config module
             default: False
             Use a longtable environment instead of tabular. Requires adding
-            a \\usepackage{longtable} to your LaTeX preamble.
+            a \usepackage{longtable} to your LaTeX preamble.
         escape : boolean, default will be read from the pandas config module
             default: True
             When set to False prevents from escaping latex special
@@ -1641,15 +1641,24 @@ def to_latex(self, buf=None, columns=None, col_space=None, header=True,
             defaults to 'ascii' on Python 2 and 'utf-8' on Python 3.
         decimal : string, default '.'
             Character recognized as decimal separator, e.g. ',' in Europe
+        multicol : boolean, default False
+            Use \multicolumn to enhance MultiIndex columns.
+        multirow : boolean, default False
+            Use \multirow to enhance MultiIndex rows. Requires adding a
+            \usepackage{multirow} to your LaTeX preamble.
 
-            .. versionadded:: 0.18.0
+            .. versionadded:: 0.19.0
 
         """
         # Get defaults from the pandas config
         if longtable is None:
             longtable = get_option("display.latex.longtable")
         if escape is None:
             escape = get_option("display.latex.escape")
+        if multicol is None:
+            multicol = get_option("display.latex.multicol")
+        if multirow is None:
+            multirow = get_option("display.latex.multirow")
 
         formatter = fmt.DataFrameFormatter(self, buf=buf, columns=columns,
                                            col_space=col_space, na_rep=na_rep,
@@ -1661,7 +1670,8 @@ def to_latex(self, buf=None, columns=None, col_space=None, header=True,
                                            index_names=index_names,
                                            escape=escape, decimal=decimal)
         formatter.to_latex(column_format=column_format, longtable=longtable,
-                           encoding=encoding)
+                           encoding=encoding, multicol=multicol,
+                           multirow=multirow)
 
         if buf is None:
             return formatter.buf.getvalue()

pandas/formats/format.py

@@ -646,13 +646,15 @@ def _join_multiline(self, *strcols):
             st = ed
         return '\n\n'.join(str_lst)
 
-    def to_latex(self, column_format=None, longtable=False, encoding=None):
+    def to_latex(self, column_format=None, longtable=False, encoding=None,
+                 multicol=False, multirow=False):
         """
         Render a DataFrame to a LaTeX tabular/longtable environment output.
         """
 
         latex_renderer = LatexFormatter(self, column_format=column_format,
-                                        longtable=longtable)
+                                        longtable=longtable, multicol=multicol,
+                                        multirow=multirow)
 
         if encoding is None:
             encoding = 'ascii' if compat.PY2 else 'utf-8'
@@ -820,11 +822,14 @@ class LatexFormatter(TableFormatter):
     HTMLFormatter
     """
 
-    def __init__(self, formatter, column_format=None, longtable=False):
+    def __init__(self, formatter, column_format=None, longtable=False,
+                 multicol=False, multirow=False):
         self.fmt = formatter
         self.frame = self.fmt.frame
         self.column_format = column_format
         self.longtable = longtable
+        self.multicol = multicol
+        self.multirow = multirow
 
     def write_result(self, buf):
         """
@@ -850,10 +855,15 @@ def get_col_type(dtype):
             clevels = self.frame.columns.nlevels
             strcols.pop(0)
             name = any(self.frame.index.names)
+            cname = any(self.frame.columns.names)
+            lastcol = self.frame.index.nlevels - 1
             for i, lev in enumerate(self.frame.index.levels):
                 lev2 = lev.format()
                 blank = ' ' * len(lev2[0])
-                lev3 = [blank] * clevels
+                if cname and i == lastcol:
+                    lev3 = [x if x else '{}' for x in self.frame.columns.names]
+                else:
+                    lev3 = [blank] * clevels
                 if name:
                     lev3.append(lev.name)
                 for level_idx, group in itertools.groupby(
@@ -881,10 +891,15 @@ def get_col_type(dtype):
             buf.write('\\begin{longtable}{%s}\n' % column_format)
             buf.write('\\toprule\n')
 
-        nlevels = self.frame.columns.nlevels
+        ilevels = self.frame.index.nlevels
+        clevels = self.frame.columns.nlevels
+        nlevels = clevels
         if any(self.frame.index.names):
             nlevels += 1
-        for i, row in enumerate(zip(*strcols)):
+        strrows = list(zip(*strcols))
+        clinebuf = []
+
+        for i, row in enumerate(strrows):
             if i == nlevels and self.fmt.header:
                 buf.write('\\midrule\n')  # End of header
                 if self.longtable:
@@ -906,8 +921,50 @@ def get_col_type(dtype):
                          if x else '{}') for x in row]
             else:
                 crow = [x if x else '{}' for x in row]
+            if i < clevels and self.fmt.header and self.multicol:
+                row2 = list(crow[:ilevels])
+                ncol = 1
+                coltext = ''
+
+                def appendCol():
+                    if ncol > 1:
+                        row2.append('\\multicolumn{{{0:d}}}{{c}}{{{1:s}}}'
+                                    .format(ncol, coltext.strip()))
+                    else:
+                        row2.append(coltext)
+                for c in crow[ilevels:]:
+                    if c.strip():
+                        if coltext:
+                            appendCol()
+                        coltext = c
+                        ncol = 1
+                    else:
+                        ncol += 1
+                if coltext:
+                    appendCol()
+                crow = row2
+            if i >= nlevels and self.fmt.index and self.multirow:
+                for j in range(ilevels):
+                    if crow[j].strip():
+                        nrow = 1
+                        for r in strrows[i + 1:]:
+                            if not r[j].strip():
+                                nrow += 1
+                            else:
+                                break
+                        if nrow > 1:
+                            crow[j] = '\\multirow{{{0:d}}}{{*}}{{{1:s}}}'\
+                                      .format(nrow, crow[j].strip())
+                            clinebuf.append([nrow, j + 1])
             buf.write(' & '.join(crow))
             buf.write(' \\\\\n')
+            if self.multirow and i < len(strrows) - 1:
+                for cl in clinebuf:
+                    cl[0] -= 1
+                    if cl[0] == 0:
+                        buf.write('\cline{{{0:d}-{1:d}}}\n'.format(cl[1],
+                                  len(strcols)))
+                clinebuf = [x for x in clinebuf if x[0]]
 
         if not self.longtable:
             buf.write('\\bottomrule\n')

pandas/tests/formats/test_format.py

@@ -3004,6 +3004,66 @@ def test_to_latex_multiindex(self):
 
         self.assertEqual(result, expected)
 
+    def test_to_latex_multicolrow(self):
+        df = pd.DataFrame({
+                    ('c1',0):dict((x,x) for x in range(5)),
+                    ('c1',1):dict((x,x+5) for x in range(5)),
+                    ('c2',0):dict((x,x) for x in range(5)),
+                    ('c2',1):dict((x,x+5) for x in range(5)),
+                    ('c3',0):dict((x,x) for x in range(5))
+                    })
+        result = df.to_latex(multicol=True)
+        expected = r"""\begin{tabular}{lrrrrr}
+\toprule
+{} & \multicolumn{2}{c}{c1} & \multicolumn{2}{c}{c2} & c3 \\
+{} &  0 &  1 &  0 &  1 &  0 \\
+\midrule
+0 &  0 &  5 &  0 &  5 &  0 \\
+1 &  1 &  6 &  1 &  6 &  1 \\
+2 &  2 &  7 &  2 &  7 &  2 \\
+3 &  3 &  8 &  3 &  8 &  3 \\
+4 &  4 &  9 &  4 &  9 &  4 \\
+\bottomrule
+\end{tabular}
+"""
+        self.assertEqual(result, expected)
+
+        result = df.T.to_latex(multirow=True)
+        expected = r"""\begin{tabular}{llrrrrr}
+\toprule
+   &   &  0 &  1 &  2 &  3 &  4 \\
+\midrule
+\multirow{2}{*}{c1} & 0 &  0 &  1 &  2 &  3 &  4 \\
+   & 1 &  5 &  6 &  7 &  8 &  9 \\
+\cline{1-7}
+\multirow{2}{*}{c2} & 0 &  0 &  1 &  2 &  3 &  4 \\
+   & 1 &  5 &  6 &  7 &  8 &  9 \\
+\cline{1-7}
+c3 & 0 &  0 &  1 &  2 &  3 &  4 \\
+\bottomrule
+\end{tabular}
+"""
+        self.assertEqual(result, expected)
+
+        df.index = df.T.index
+        result = df.T.to_latex(multirow=True,multicol=True)
+        expected = r"""\begin{tabular}{llrrrrr}
+\toprule
+   &   & \multicolumn{2}{c}{c1} & \multicolumn{2}{c}{c2} & c3 \\
+   &   &  0 &  1 &  0 &  1 &  0 \\
+\midrule
+\multirow{2}{*}{c1} & 0 &  0 &  1 &  2 &  3 &  4 \\
+   & 1 &  5 &  6 &  7 &  8 &  9 \\
+\cline{1-7}
+\multirow{2}{*}{c2} & 0 &  0 &  1 &  2 &  3 &  4 \\
+   & 1 &  5 &  6 &  7 &  8 &  9 \\
+\cline{1-7}
+c3 & 0 &  0 &  1 &  2 &  3 &  4 \\
+\bottomrule
+\end{tabular}
+"""
+        self.assertEqual(result, expected)
+
     def test_to_latex_escape(self):
         a = 'a'
         b = 'b'