ENH: API change / refactoring in Series.__getitem__ and __setitem__ to implement #86, related tightening of integer index handling from #592

Author: wesm

pandas/core/generic.py

@@ -576,8 +576,7 @@ def truncate(self, before=None, after=None, copy=True):
     if before is not None and after is not None:
         assert(before <= after)
 
-    left, right = self.index.slice_locs(before, after)
-    result = self[left:right]
+    result = self.ix[before:after]
 
     if isinstance(self.index, MultiIndex):
         result.index = self.index.truncate(before, after)

pandas/core/groupby.py

@@ -1278,18 +1278,21 @@ def generate_groups(data, label_list, shape, axis=0, factory=lambda x: x):
     elif isinstance(data, DataFrame):
         sorted_data = data.take(indexer, axis=axis)
 
-    if isinstance(data, DataFrame):
-        def slicer(data, slob):
+    if isinstance(sorted_data, DataFrame):
+        def _get_slice(slob):
             if axis == 0:
-                return data[slob]
+                return sorted_data[slob]
             else:
-                return data.ix[:, slob]
-    elif isinstance(data, BlockManager):
-        def slicer(data, slob):
-            return factory(data.get_slice(slob, axis=axis))
-    else:
-        def slicer(data, slob):
-            return data[slob]
+                return sorted_data.ix[:, slob]
+    elif isinstance(sorted_data, BlockManager):
+        def _get_slice(slob):
+            return factory(sorted_data.get_slice(slob, axis=axis))
+    elif isinstance(sorted_data, Series):
+        def _get_slice(slob):
+            return sorted_data._get_values(slob)
+    else:  # pragma: no cover
+        def _get_slice(slob):
+            return sorted_data[slob]
 
     starts, ends = lib.generate_slices(group_index.astype('i4'),
                                        np.prod(shape))
@@ -1298,7 +1301,7 @@ def slicer(data, slob):
         if start == end:
             yield i, None
         else:
-            yield i, slicer(sorted_data, slice(start, end))
+            yield i, _get_slice(slice(start, end))
 
 def get_group_index(label_list, shape):
     if len(label_list) == 1:

pandas/core/indexing.py

@@ -31,7 +31,7 @@ def __getitem__(self, key):
         else:
             return self._getitem_axis(key, axis=0)
 
-    def _get(self, label, axis=0):
+    def _get_label(self, label, axis=0):
         try:
             return self.obj.xs(label, axis=axis, copy=False)
         except Exception:
@@ -96,7 +96,7 @@ def _getitem_tuple(self, tup):
         # a bit kludgy
         if isinstance(self.obj._get_axis(0), MultiIndex):
             try:
-                return self._get(tup, axis=0)
+                return self._get_label(tup, axis=0)
             except (KeyError, TypeError):
                 pass
 
@@ -156,40 +156,36 @@ def _getitem_axis(self, key, axis=0):
             if com.is_integer(key):
                 if isinstance(labels, MultiIndex):
                     try:
-                        return self._get(key, axis=0)
+                        return self._get_label(key, axis=0)
                     except (KeyError, TypeError):
                         if _is_integer_index(self.obj.index.levels[0]):
                             raise
 
                 if not is_int_index:
                     idx = labels[key]
 
-            return self._get(idx, axis=0)
+            return self._get_label(idx, axis=0)
         else:
             labels = self.obj._get_axis(axis)
             lab = key
             if com.is_integer(key) and not _is_integer_index(labels):
                 lab = labels[key]
-            return self._get(lab, axis=axis)
+            return self._get_label(lab, axis=axis)
 
     def _getitem_iterable(self, key, axis=0):
         labels = self.obj._get_axis(axis)
         axis_name = self.obj._get_axis_name(axis)
 
-        # asarray can be unsafe, NumPy strings are weird
-        if isinstance(key, Index):
-            # want Index objects to pass through untouched
-            keyarr = key
-        else:
-            keyarr = _asarray_tuplesafe(key)
-
-        if keyarr.dtype == np.bool_:
-            if _is_series(key):
-                if not key.index.equals(labels):
-                    raise IndexingError('Cannot use boolean index with '
-                                        'misaligned or unequal labels')
+        if com._is_bool_indexer(key):
+            key = _check_bool_indexer(labels, key)
             return self.obj.reindex(**{axis_name : labels[np.asarray(key)]})
         else:
+            if isinstance(key, Index):
+                # want Index objects to pass through untouched
+                keyarr = key
+            else:
+                # asarray can be unsafe, NumPy strings are weird
+                keyarr = _asarray_tuplesafe(key)
             if _is_integer_dtype(keyarr) and not _is_integer_index(labels):
                 keyarr = labels.take(keyarr)
 
@@ -244,14 +240,12 @@ def _convert_to_indexer(self, obj, axis=0):
             return slicer
 
         elif _is_list_like(obj):
-            objarr = _asarray_tuplesafe(obj)
-
-            if objarr.dtype == np.bool_:
-                if not obj.index.equals(labels):
-                    raise IndexingError('Cannot use boolean index with '
-                                        'misaligned or unequal labels')
+            if com._is_bool_indexer(obj):
+                objarr = _check_bool_indexer(labels, obj)
                 return objarr
             else:
+                objarr = _asarray_tuplesafe(obj)
+
                 # If have integer labels, defer to label-based indexing
                 if _is_integer_dtype(objarr) and not is_int_index:
                     return objarr
@@ -330,14 +324,33 @@ class _SeriesIndexer(_NDFrameIndexer):
     >>> ts.ix[date1:date2] = 0
     """
 
-    def _get(self, label, axis=0):
-        return self.obj[label]
+    def _get_integer(self, indexer, axis=0):
+        return self.obj._get_values(indexer)
 
-    def _slice(self, obj, axis=0):
-        return self.obj[obj]
+    def _get_label(self, key, axis=0):
+        return self.obj[key]
+
+    def _slice(self, indexer, axis=0):
+        return self.obj._get_values(indexer)
 
     def _setitem_with_indexer(self, indexer, value):
-        self.obj[indexer] = value
+        self.obj._set_values(indexer, value)
+
+def _check_bool_indexer(ax, key):
+    # boolean indexing, need to check that the data are aligned, otherwise
+    # disallowed
+    result = key
+    if _is_series(key) and key.dtype == np.bool_:
+        if not key.index.equals(ax):
+            result = key.reindex(ax)
+
+    if isinstance(result, np.ndarray) and result.dtype == np.object_:
+        mask = com.isnull(result)
+        if mask.any():
+            raise IndexingError('cannot index with vector containing '
+                                'NA / NaN values')
+
+    return result
 
 def _is_series(obj):
     from pandas.core.series import Series
@@ -395,4 +408,3 @@ def _maybe_droplevels(index, key):
 
     return index
 
-_isboolarr = lambda x: np.asarray(x).dtype == np.bool_