REF: renamed xby/yby to rows/cols in pivot_table

Author: wesm

doc/source/reshaping.rst

@@ -208,8 +208,8 @@ tables. It takes a number of arguments
 
 - ``data``: A DataFrame object
 - ``values``: column to aggregate
-- ``xby``: list of columns to group by on the `x`-axis
-- ``yby``: list of columns to group by on the `y`-axis
+- ``rows``: list of columns to group by on the table rows
+- ``cols``: list of columns to group by on the table columns
 - ``aggfunc``: function to use for aggregation, defaulting to ``numpy.mean``
 
 Consider a data set like this:
@@ -227,8 +227,8 @@ We can produce pivot tables from this data very easily:
 
 .. ipython:: python
 
-   pivot_table(df, values='D', xby=['A', 'B'], yby=['C'])
-   pivot_table(df, values='D', xby=['B'], yby=['A', 'C'], aggfunc=np.sum)
+   pivot_table(df, values='D', rows=['A', 'B'], cols=['C'])
+   pivot_table(df, values='D', rows=['B'], cols=['A', 'C'], aggfunc=np.sum)
 
 The result object is a DataFrame having potentially hierarchical indexes on the
 rows and columns. If the ``values`` column name is not given, the pivot table
@@ -237,12 +237,12 @@ hierarchy in the columns:
 
 .. ipython:: python
 
-   pivot_table(df, xby=['A', 'B'], yby=['C'])
+   pivot_table(df, rows=['A', 'B'], cols=['C'])
 
 You can render a nice output of the table omitting the missing values by
 calling ``to_string`` if you wish:
 
 .. ipython:: python
 
-   table = pivot_table(df, xby=['A', 'B'], yby=['C'])
+   table = pivot_table(df, rows=['A', 'B'], cols=['C'])
    print table.to_string(na_rep='')

pandas/tools/pivot.py

@@ -1,7 +1,7 @@
 from pandas import DataFrame
 import numpy as np
 
-def pivot_table(data, values=None, xby=None, yby=None, aggfunc=np.mean,
+def pivot_table(data, values=None, rows=None, cols=None, aggfunc=np.mean,
                 fill_value=None):
     """
     Create a spreadsheet-style pivot table as a DataFrame. The levels in the
@@ -12,9 +12,9 @@ def pivot_table(data, values=None, xby=None, yby=None, aggfunc=np.mean,
     ----------
     data : DataFrame
     values : column to aggregate, optional
-    xby : list
+    rows : list
         Columns to group on the x-axis of the pivot table
-    yby : list
+    cols : list
         Columns to group on the x-axis of the pivot table
     aggfunc : function, default numpy.mean
     fill_value : scalar, default None
@@ -34,8 +34,8 @@ def pivot_table(data, values=None, xby=None, yby=None, aggfunc=np.mean,
     7  bar two small  6
     8  bar two large  7
 
-    >>> table = pivot_table(df, values='D', xby=['A, 'B'],
-                            yby=['C'], aggfunc=np.sum)
+    >>> table = pivot_table(df, values='D', rows=['A, 'B'],
+                            cols=['C'], aggfunc=np.sum)
     >>> table
               small  large
     foo  one  1      4
@@ -47,10 +47,10 @@ def pivot_table(data, values=None, xby=None, yby=None, aggfunc=np.mean,
     -------
     table : DataFrame
     """
-    xby = _convert_by(xby)
-    yby = _convert_by(yby)
+    rows = _convert_by(rows)
+    cols = _convert_by(cols)
 
-    keys = xby + yby
+    keys = rows + cols
     grouped = data.groupby(keys)
 
     if values is not None:
@@ -59,7 +59,7 @@ def pivot_table(data, values=None, xby=None, yby=None, aggfunc=np.mean,
     agged = grouped.agg(aggfunc)
 
     table = agged
-    for k in yby:
+    for k in cols:
         table = table.unstack(level=k)
 
     if fill_value is not None:
@@ -100,5 +100,5 @@ def _sample(values, n):
     data = DataFrame(data)
 
     table = pivot_table(data, values='values',
-                        xby=['k1', 'k2'], yby=['k3', 'k4'])
+                        rows=['k1', 'k2'], cols=['k3', 'k4'])
 

pandas/tools/tests/test_pivot.py

@@ -22,28 +22,28 @@ def setUp(self):
                                'E' : np.random.randn(11)})
 
     def test_pivot_table(self):
-        xby = ['A', 'B']
-        yby=  'C'
-        table = pivot_table(self.data, values='D', xby=xby, yby=yby)
+        rows = ['A', 'B']
+        cols=  'C'
+        table = pivot_table(self.data, values='D', rows=rows, cols=cols)
 
-        if len(xby) > 1:
-            self.assertEqual(table.index.names, xby)
+        if len(rows) > 1:
+            self.assertEqual(table.index.names, rows)
         else:
-            self.assertEqual(table.index.name, xby[0])
+            self.assertEqual(table.index.name, rows[0])
 
-        if len(yby) > 1:
-            self.assertEqual(table.columns.names, yby)
+        if len(cols) > 1:
+            self.assertEqual(table.columns.names, cols)
         else:
-            self.assertEqual(table.columns.name, yby[0])
+            self.assertEqual(table.columns.name, cols[0])
 
-        expected = self.data.groupby(xby + [yby])['D'].agg(np.mean).unstack()
+        expected = self.data.groupby(rows + [cols])['D'].agg(np.mean).unstack()
         assert_frame_equal(table, expected)
 
     def test_pivot_table_multiple(self):
-        xby = ['A', 'B']
-        yby=  'C'
-        table = pivot_table(self.data, xby=xby, yby=yby)
-        expected = self.data.groupby(xby + [yby]).agg(np.mean).unstack()
+        rows = ['A', 'B']
+        cols=  'C'
+        table = pivot_table(self.data, rows=rows, cols=cols)
+        expected = self.data.groupby(rows + [cols]).agg(np.mean).unstack()
         assert_frame_equal(table, expected)
 
 if __name__ == '__main__':