ENH: inplace option for sort_index

Author: Chang She

pandas/core/frame.py

@@ -2409,7 +2409,8 @@ def duplicated(self, cols=None, take_last=False):
     #----------------------------------------------------------------------
     # Sorting
 
-    def sort(self, columns=None, column=None, axis=0, ascending=True):
+    def sort(self, columns=None, column=None, axis=0, ascending=True,
+             inplace=False):
         """
         Sort DataFrame either by labels (along either axis) or by the values in
         column(s)
@@ -2423,6 +2424,8 @@ def sort(self, columns=None, column=None, axis=0, ascending=True):
             Sort ascending vs. descending
         axis : {0, 1}
             Sort index/rows versus columns
+        inplace : boolean, default False
+            Sort the DataFrame without creating a new instance
 
         Returns
         -------
@@ -2432,9 +2435,10 @@ def sort(self, columns=None, column=None, axis=0, ascending=True):
             import warnings
             warnings.warn("column is deprecated, use columns", FutureWarning)
             columns = column
-        return self.sort_index(by=columns, axis=axis, ascending=ascending)
+        return self.sort_index(by=columns, axis=axis, ascending=ascending,
+                               inplace=inplace)
 
-    def sort_index(self, axis=0, by=None, ascending=True):
+    def sort_index(self, axis=0, by=None, ascending=True, inplace=False):
         """
         Sort DataFrame either by labels (along either axis) or by the values in
         a column
@@ -2448,6 +2452,8 @@ def sort_index(self, axis=0, by=None, ascending=True):
             for a nested sort.
         ascending : boolean, default True
             Sort ascending vs. descending
+        inplace : boolean, default False
+            Sort the DataFrame without creating a new instance
 
         Returns
         -------
@@ -2470,7 +2476,18 @@ def sort_index(self, axis=0, by=None, ascending=True):
         if not ascending:
             indexer = indexer[::-1]
 
-        return self.take(indexer, axis=axis)
+        if inplace:
+            if axis == 1:
+                self._data = self._data.reindex_items(self._data.items[indexer],
+                                                      copy=False)
+            elif axis == 0:
+                self._data = self._data.take(indexer)
+            else:
+                raise ValueError('Axis must be 0 or 1, got %s' % str(axis))
+            self._clear_item_cache()
+            return self
+        else:
+            return self.take(indexer, axis=axis)
 
     def sortlevel(self, level=0, axis=0, ascending=True):
         """

pandas/core/internals.py

@@ -103,22 +103,18 @@ def merge(self, other):
         return _merge_blocks([self, other], self.ref_items)
 
     def reindex_axis(self, indexer, mask, needs_masking, axis=0,
-                     fill_value=np.nan, out=None):
+                     fill_value=np.nan):
         """
         Reindex using pre-computed indexer information
         """
         if self.values.size > 0:
             new_values = com.take_fast(self.values, indexer, mask,
                                        needs_masking, axis=axis,
-                                       fill_value=fill_value,
-                                       out=out)
+                                       fill_value=fill_value)
         else:
             shape = list(self.shape)
             shape[axis] = len(indexer)
-            if out is not None and (out.shape == shape):
-                new_values = out
-            else:
-                new_values = np.empty(shape)
+            new_values = np.empty(shape)
             new_values.fill(fill_value)
         return make_block(new_values, self.items, self.ref_items)
 

pandas/tests/test_frame.py

@@ -4557,6 +4557,53 @@ def test_sort_index_multicolumn(self):
         expected = frame.take(indexer)
         assert_frame_equal(result, expected)
 
+    def test_sort_index_inplace(self):
+        frame = DataFrame(np.random.randn(4, 4), index=[1, 2, 3, 4],
+                          columns=['A', 'B', 'C', 'D'])
+
+        # axis=0
+        unordered = frame.ix[[3, 2, 4, 1]]
+        df = unordered.copy()
+        df.sort_index(inplace=True)
+        expected = frame
+        assert_frame_equal(df, expected)
+
+        df = unordered.copy()
+        df.sort_index(ascending=False, inplace=True)
+        expected = frame[::-1]
+        assert_frame_equal(df, expected)
+
+        # axis=1
+        unordered = frame.ix[:, ['D', 'B', 'C', 'A']]
+        df = unordered.copy()
+        df.sort_index(axis=1, inplace=True)
+        expected = frame
+        assert_frame_equal(df, expected)
+
+        df = unordered.copy()
+        df.sort_index(axis=1, ascending=False, inplace=True)
+        expected = frame.ix[:, ::-1]
+        assert_frame_equal(df, expected)
+
+    def test_sort_inplace(self):
+        frame = DataFrame(np.random.randn(4, 4), index=[1, 2, 3, 4],
+                          columns=['A', 'B', 'C', 'D'])
+
+        sorted_df = frame.copy()
+        sorted_df.sort(columns='A', inplace=True)
+        expected = frame.sort_index(by='A')
+        assert_frame_equal(sorted_df, expected)
+
+        sorted_df = frame.copy()
+        sorted_df.sort(columns='A', ascending=False, inplace=True)
+        expected = frame.sort_index(by='A', ascending=False)
+        assert_frame_equal(sorted_df, expected)
+
+        sorted_df = frame.copy()
+        sorted_df.sort(columns=['A', 'B'], ascending=False, inplace=True)
+        expected = frame.sort_index(by=['A', 'B'], ascending=False)
+        assert_frame_equal(sorted_df, expected)
+
     def test_frame_column_inplace_sort_exception(self):
         s = self.frame['A']
         self.assertRaises(Exception, s.sort)