ENH: multiple group selection from hierarchical index via reindex and .ix, close #134

Author: wesm

pandas/core/frame.py

@@ -1917,15 +1917,11 @@ def reindex_axis(self, labels, axis=0, method=None, level=None, copy=True,
             raise ValueError('Must specify axis=0 or 1')
 
     def _reindex_index(self, new_index, method, copy, level, fill_value=np.nan):
-        if level is not None:
-            assert(isinstance(new_index, MultiIndex))
         new_index, indexer = self.index.reindex(new_index, method, level)
         return self._reindex_with_indexers(new_index, indexer, None, None,
                                            copy, fill_value)
 
     def _reindex_columns(self, new_columns, copy, level, fill_value=np.nan):
-        if level is not None:
-            assert(isinstance(new_columns, MultiIndex))
         new_columns, indexer = self.columns.reindex(new_columns, level=level)
         return self._reindex_with_indexers(None, None, new_columns, indexer,
                                            copy, fill_value)
@@ -1934,6 +1930,7 @@ def _reindex_with_indexers(self, index, row_indexer, columns, col_indexer,
                                copy, fill_value):
         new_data = self._data
         if row_indexer is not None:
+            row_indexer = com._ensure_int32(row_indexer)
             new_data = new_data.reindex_indexer(index, row_indexer, axis=1,
                                                 fill_value=fill_value)
         elif index is not None and index is not new_data.axes[1]:
@@ -1942,6 +1939,7 @@ def _reindex_with_indexers(self, index, row_indexer, columns, col_indexer,
 
         if col_indexer is not None:
             # TODO: speed up on homogeneous DataFrame objects
+            col_indexer = com._ensure_int32(col_indexer)
             new_data = new_data.reindex_indexer(columns, col_indexer, axis=0,
                                                 fill_value=fill_value)
         elif columns is not None and columns is not new_data.axes[0]:

pandas/core/index.py

@@ -641,8 +641,8 @@ def reindex(self, target, method=None, level=None):
         """
         target = _ensure_index(target)
         if level is not None:
-            _, indexer, _ = self._join_level(target, level, how='left',
-                                                  return_indexers=True)
+            _, indexer, _ = self._join_level(target, level, how='right',
+                                             return_indexers=True)
         else:
             if self.equals(target):
                 indexer = None
@@ -726,7 +726,6 @@ def _join_level(self, other, level, how='left', return_indexers=False):
             how = {'right': 'left', 'left': 'right'}.get(how, how)
 
         level = left._get_level_number(level)
-
         old_level = left.levels[level]
 
         new_level, left_lev_indexer, right_lev_indexer = \
@@ -750,10 +749,10 @@ def _join_level(self, other, level, how='left', return_indexers=False):
 
             join_index = MultiIndex(levels=new_levels, labels=new_labels,
                                     names=left.names)
+            left_indexer = np.arange(len(left))[new_lev_labels != -1]
         else:
             join_index = left
-
-        left_indexer = None
+            left_indexer = None
 
         if right_lev_indexer is not None:
             right_indexer = right_lev_indexer.take(join_index.labels[level])
@@ -1682,7 +1681,7 @@ def reindex(self, target, method=None, level=None):
         (new_index, indexer, mask) : (MultiIndex, ndarray, ndarray)
         """
         if level is not None:
-            target, _, indexer = self._join_level(target, level, how='left',
+            target, indexer, _ = self._join_level(target, level, how='right',
                                                   return_indexers=True)
         else:
             if self.equals(target):

pandas/core/indexing.py

@@ -170,7 +170,7 @@ def _getitem_axis(self, key, axis=0):
 
             if hasattr(key, 'ndim') and key.ndim > 1:
                 raise ValueError('Cannot index with multidimensional key')
- 
+
             return self._getitem_iterable(key, axis=axis)
         elif axis == 0:
             is_int_index = _is_integer_index(labels)
@@ -197,11 +197,19 @@ def _getitem_axis(self, key, axis=0):
 
     def _getitem_iterable(self, key, axis=0):
         labels = self.obj._get_axis(axis)
-        axis_name = self.obj._get_axis_name(axis)
+        # axis_name = self.obj._get_axis_name(axis)
+
+        def _reindex(keys, level=None):
+            try:
+                return self.obj.reindex_axis(keys, axis=axis, level=level)
+            except AttributeError:
+                # Series
+                assert(axis == 0)
+                return self.obj.reindex(keys, level=level)
 
         if com._is_bool_indexer(key):
             key = _check_bool_indexer(labels, key)
-            return self.obj.reindex(**{axis_name: labels[np.asarray(key)]})
+            return _reindex(labels[np.asarray(key)])
         else:
             if isinstance(key, Index):
                 # want Index objects to pass through untouched
@@ -212,7 +220,14 @@ def _getitem_iterable(self, key, axis=0):
             if _is_integer_dtype(keyarr) and not _is_integer_index(labels):
                 keyarr = labels.take(keyarr)
 
-            return self.obj.reindex(**{axis_name: keyarr})
+            # this is not the most robust, but...
+            if (isinstance(labels, MultiIndex) and
+                not isinstance(keyarr[0], tuple)):
+                level = 0
+            else:
+                level = None
+
+            return _reindex(keyarr, level=level)
 
     def _convert_to_indexer(self, obj, axis=0):
         """

pandas/core/panel.py

@@ -337,7 +337,7 @@ def _getitem_multilevel(self, key):
                 result.index = result_index
             else:
                 new_values = self.values[loc, :, :]
-                result = Panel(new_values, 
+                result = Panel(new_values,
                                items=self.items[loc],
                                major_axis=self.major_axis,
                                minor_axis=self.minor_axis)
@@ -699,6 +699,37 @@ def reindex(self, major=None, items=None, minor=None, method=None,
 
         return result
 
+    def reindex_axis(self, labels, axis=0, method=None, level=None, copy=True):
+        """Conform Panel to new index with optional filling logic, placing
+        NA/NaN in locations having no value in the previous index. A new object
+        is produced unless the new index is equivalent to the current one and
+        copy=False
+
+        Parameters
+        ----------
+        index : array-like, optional
+            New labels / index to conform to. Preferably an Index object to
+            avoid duplicating data
+        axis : {0, 1}
+            0 -> index (rows)
+            1 -> columns
+        method : {'backfill', 'bfill', 'pad', 'ffill', None}, default None
+            Method to use for filling holes in reindexed DataFrame
+            pad / ffill: propagate last valid observation forward to next valid
+            backfill / bfill: use NEXT valid observation to fill gap
+        copy : boolean, default True
+            Return a new object, even if the passed indexes are the same
+        level : int or name
+            Broadcast across a level, matching Index values on the
+            passed MultiIndex level
+
+        Returns
+        -------
+        reindexed : Panel
+        """
+        self._consolidate_inplace()
+        return self._reindex_axis(labels, method, axis, copy)
+
     def reindex_like(self, other, method=None):
         """
         Reindex Panel to match indices of another Panel

pandas/core/series.py

@@ -1906,6 +1906,7 @@ def reindex(self, index=None, method=None, level=None, fill_value=np.nan,
 
         new_index, fill_vec = self.index.reindex(index, method=method,
                                                  level=level)
+        fill_vec = com._ensure_int32(fill_vec)
         new_values = com.take_1d(self.values, fill_vec, fill_value=fill_value)
         return Series(new_values, index=new_index, name=self.name)
 

pandas/tests/test_index.py

@@ -1386,11 +1386,18 @@ def test_reindex_level(self):
         idx = Index(['one'])
 
         target, indexer = self.index.reindex(idx, level='second')
-        target2, indexer2 = idx.reindex(self.index, idx, level='second')
+        target2, indexer2 = idx.reindex(self.index, level='second')
+
+        exp_index = self.index.join(idx, level='second', how='right')
+        exp_index2 = self.index.join(idx, level='second', how='left')
 
-        exp_index = self.index.join(idx, level='second', how='left')
         self.assert_(target.equals(exp_index))
-        self.assert_(target2.equals(exp_index))
+        exp_indexer = np.array([0, 2, 4])
+        self.assert_(np.array_equal(indexer, exp_indexer))
+
+        self.assert_(target2.equals(exp_index2))
+        exp_indexer2 = np.array([0, -1, 0, -1, 0, -1])
+        self.assert_(np.array_equal(indexer2, exp_indexer2))
 
     def test_has_duplicates(self):
         self.assert_(not self.index.has_duplicates)

pandas/tests/test_multilevel.py

@@ -83,6 +83,7 @@ def _check_op(opname):
             op = getattr(DataFrame, opname)
             month_sums = self.ymd.sum(level='month')
             result = op(self.ymd, month_sums, level='month')
+
             broadcasted = self.ymd.groupby(level='month').transform(np.sum)
             expected = op(self.ymd, broadcasted)
             assert_frame_equal(result, expected)
@@ -1188,6 +1189,23 @@ def test_mixed_depth_pop(self):
         assert_frame_equal(expected, result)
         assert_frame_equal(df1, df2)
 
+    def test_reindex_level_partial_selection(self):
+        result = self.frame.reindex(['foo', 'qux'], level=0)
+        expected = self.frame.ix[[0, 1, 2, 7, 8, 9]]
+        assert_frame_equal(result, expected)
+
+        result = self.frame.T.reindex_axis(['foo', 'qux'], axis=1, level=0)
+        assert_frame_equal(result, expected.T)
+
+        result = self.frame.ix[['foo', 'qux']]
+        assert_frame_equal(result, expected)
+
+        result = self.frame['A'].ix[['foo', 'qux']]
+        assert_series_equal(result, expected['A'])
+
+        result = self.frame.T.ix[:, ['foo', 'qux']]
+        assert_frame_equal(result, expected.T)
+
     def test_drop_level(self):
         result = self.frame.drop(['bar', 'qux'], level='first')
         expected = self.frame.ix[[0, 1, 2, 5, 6]]