ENH: AmbiguousIndexError not raised anymore, prefer label-based indexing, other multi-lev compat

Author: wesm

pandas/core/common.py

@@ -200,6 +200,13 @@ def _pfixed(s, space, nanRep=None, float_format=None):
     else:
         return (' %s' % s)[:space].ljust(space)
 
+def _stringify(col):
+    # unicode workaround
+    if isinstance(col, tuple):
+        return str(col)
+    else:
+        return '%s' % col
+
 def _format(s, nanRep=None, float_format=None):
     if isinstance(s, float):
         if nanRep is not None and isnull(s):

pandas/core/frame.py

@@ -22,10 +22,11 @@
 
 from pandas.core.common import (isnull, notnull, PandasError, _ensure_index,
                                 _try_sort, _pfixed, _default_index,
-                                _infer_dtype)
+                                _infer_dtype, _stringify)
 from pandas.core.daterange import DateRange
 from pandas.core.generic import AxisProperty, NDFrame
 from pandas.core.index import Index, MultiIndex, NULL_INDEX
+from pandas.core.indexing import _DataFrameIndexer, _maybe_droplevels
 from pandas.core.internals import BlockManager, make_block, form_blocks
 from pandas.core.series import Series, _is_bool_indexer
 import pandas.core.common as common
@@ -242,6 +243,15 @@ def axes(self):
     def _constructor(self):
         return DataFrame
 
+    # Fancy indexing
+    _ix = None
+    @property
+    def ix(self):
+        if self._ix is None:
+            self._ix = _DataFrameIndexer(self)
+
+        return self._ix
+
     #----------------------------------------------------------------------
     # Class behavior
 
@@ -502,7 +512,7 @@ def _myformat(v):
         if formatters is None:
             formatters = {}
 
-        def _stringify(col):
+        def _format_col(col):
             formatter = formatters.get(col, _myformat)
             return [formatter(x) for x in self[col]]
 
@@ -519,7 +529,7 @@ def _stringify(col):
         else:
             (str_index,
              str_columns) = self._get_formatted_labels(sparsify=sparsify)
-            stringified = [str_columns[i] + _stringify(c)
+            stringified = [str_columns[i] + _format_col(c)
                            for i, c in enumerate(columns)]
             to_write.append(adjoin(1, str_index, *stringified))
 
@@ -567,13 +577,6 @@ def info(self, verbose=True, buf=sys.stdout):
 
         cols = self.columns
 
-        def _stringify(col):
-            # unicode workaround
-            if isinstance(col, tuple):
-                return str(col)
-            else:
-                return '%s' % col
-
         if verbose:
             print >> buf, unicode('Data columns:')
             space = max([len(_stringify(k)) for k in self.columns]) + 4
@@ -728,9 +731,7 @@ def __getitem__(self, key):
         Examples
         --------
         column = dm['A']
-
         dmSlice = dm[:20] # First 20 rows
-
         dmSelect = dm[dm.count(axis=1) > 10]
 
         Notes
@@ -752,27 +753,21 @@ def __getitem__(self, key):
             new_index = self.index[key]
             return self.reindex(new_index)
         elif isinstance(self.columns, MultiIndex):
-            loc = self.columns.get_loc(key)
-            if isinstance(loc, slice):
-                new_columns = self.columns[loc]
-                result = self.reindex(columns=new_columns)
-
-                # drop levels
-                if isinstance(key, tuple):
-                    for _ in key:
-                        new_columns = new_columns.droplevel(0)
-                else:
-                    new_columns = new_columns.droplevel(0)
-
-                result.columns = new_columns
-                return result
-            else:
-                return self._getitem_single(key)
+            return self._getitem_multilevel(key)
         else:
             return self._getitem_single(key)
 
     def _getitem_multilevel(self, key):
-        pass
+        loc = self.columns.get_loc(key)
+        if isinstance(loc, slice):
+            new_columns = self.columns[loc]
+            result = self.reindex(columns=new_columns)
+
+            # HACK: need a more general way of addressing this problem
+            result.columns = _maybe_droplevels(new_columns, key)
+            return result
+        else:
+            return self._getitem_single(key)
 
     def _getitem_single(self, key):
         values = self._data.get(key)
@@ -907,7 +902,9 @@ def xs(self, key, copy=True):
         if new_data.ndim == 1:
             return Series(new_data.as_matrix(), index=self.columns)
         else:
-            return DataFrame(new_data)
+            result = DataFrame(new_data)
+            result.index = _maybe_droplevels(result.index, key)
+            return result
 
     #----------------------------------------------------------------------
     # Reindexing
@@ -2714,18 +2711,6 @@ def dropIncompleteRows(self, specificColumns=None,
         else:
             return self.dropna(axis=0, subset=specificColumns, thresh=minObs)
 
-    #----------------------------------------------------------------------
-    # Fancy indexing
-
-    _ix = None
-    @property
-    def ix(self):
-        from pandas.core.indexing import _DataFrameIndexer
-        if self._ix is None:
-            self._ix = _DataFrameIndexer(self)
-
-        return self._ix
-
 
 def group_agg(values, bounds, f):
     """
@@ -2807,7 +2792,7 @@ def _union_if(index, new_index):
             index = index.union(new_index)
         return index
 
-    def _get_index(obj):
+    def _get_index(v):
         if isinstance(v, Series):
             return v.index
         elif isinstance(v, dict):
@@ -2871,7 +2856,6 @@ def _prep_ndarray(values, copy=True):
 
     return values
 
-
 def _rec_to_dict(arr):
     columns = list(arr.dtype.names)
     sdict = dict((k, arr[k]) for k in columns)

pandas/core/index.py

@@ -5,7 +5,7 @@
 
 import numpy as np
 
-from pandas.core.common import (_format, adjoin as _adjoin,
+from pandas.core.common import (_format, adjoin as _adjoin, _stringify,
                                 _ensure_index, _is_bool_indexer)
 import pandas.core.common as common
 import pandas._tseries as _tseries
@@ -47,9 +47,6 @@ def __new__(cls, data, dtype=object, copy=False):
         else:
             subarr = np.empty(len(data), dtype=dtype)
             subarr[:] = data
-
-        # assert(subarr.ndim == 1)
-
         return subarr.view(cls)
 
     def summary(self):
@@ -59,19 +56,21 @@ def summary(self):
             index_summary = ''
         return 'Index: %s entries%s' % (len(self), index_summary)
 
+    _indexMap = None
     @property
     def indexMap(self):
-        if not hasattr(self, '_cache_indexMap'):
-            self._cache_indexMap = _tseries.map_indices_buf(self)
+        if self._indexMap is None:
+            self._indexMap = _tseries.map_indices_buf(self)
             self._verify_integrity()
 
-        return self._cache_indexMap
+        return self._indexMap
 
+    _allDates = None
     def is_all_dates(self):
-        if not hasattr(self, '_cache_allDates'):
-            self._cache_allDates = _tseries.isAllDates(self)
+        if self._allDates is None:
+            self._allDates = _tseries.isAllDates(self)
 
-        return self._cache_allDates
+        return self._allDates
 
     def _verify_integrity(self):
         if len(self.indexMap) < len(self):
@@ -128,7 +127,7 @@ def format(self, vertical=False):
                 to_join.append(dt.strftime("%Y-%m-%d"))
             return to_join
 
-        return ['%s' % x for x in self]
+        return [_stringify(x) for x in self]
 
     def equals(self, other):
         """
@@ -425,12 +424,12 @@ def from_tuples(cls, tuples, sortorder=None):
 
     @property
     def indexMap(self):
-        if not hasattr(self, '_cache_indexMap'):
+        if self._indexMap is None:
             zipped = zip(*self.labels)
-            self._cache_indexMap = _tseries.map_indices_list(zipped)
+            self._indexMap = _tseries.map_indices_list(zipped)
             self._verify_integrity()
 
-        return self._cache_indexMap
+        return self._indexMap
 
     @property
     def nlevels(self):

pandas/core/indexing.py

@@ -1,8 +1,5 @@
 import numpy as np
 
-from pandas.core.frame import DataFrame
-from pandas.core.series import Series
-
 class _SeriesIndexer(object):
     """
     Class to support fancy indexing, potentially using labels
@@ -33,6 +30,8 @@ def __setitem__(self, key, value):
         op()
 
     def _fancy_index(self, key, value=None, operation='get'):
+        from pandas.core.series import Series
+
         # going to great lengths to avoid code dup
         series = self.series
 
@@ -134,7 +133,7 @@ def _convert_to_indexer(self, obj, axis=0):
         Going by Zen of Python?
         "In the face of ambiguity, refuse the temptation to guess."
         raise AmbiguousIndexError with integer labels?
-
+        - No, prefer label-based indexing
         """
         index = self.frame._get_axis(axis)
         is_int_index = _is_integer_index(index)
@@ -145,29 +144,25 @@ def _convert_to_indexer(self, obj, axis=0):
             else:
                 return obj
         elif _is_list_like(obj):
-            objarr = np.asarray(obj)
+            objarr = _asarray_tuplesafe(obj)
 
-            if _is_integer_dtype(objarr):
-                if is_int_index:
-                    raise AmbiguousIndexError('integer labels')
-
-                # retrieve the indices corresponding
-                return objarr
-            elif objarr.dtype == np.bool_:
+            if objarr.dtype == np.bool_:
                 if not obj.index.equals(index):
                     raise Exception('Cannot use boolean index with misaligned '
                                     'or unequal labels')
                 return objarr
             else:
+                # If have integer labels, defer to label-based indexing
+                if _is_integer_dtype(objarr) and not is_int_index:
+                    return objarr
+
                 indexer, mask = index.get_indexer(objarr)
                 if not mask.all():
                     raise KeyError('%s not in index' % objarr[-mask])
 
                 return indexer
         else:
-            if _is_int_like(obj):
-                if is_int_index:
-                    raise AmbiguousIndexError('integer labels')
+            if _is_int_like(obj) and not is_int_index:
                 return obj
             return index.get_loc(obj)
 
@@ -189,43 +184,41 @@ def _fancy_getitem_axis(self, key, axis=0):
         elif _is_list_like(key):
             return self._fancy_getitem(key, axis=axis)
         elif axis == 0:
-            idx = key
-            if isinstance(key, int):
-                if _is_integer_index(self.frame.index):
-                    raise AmbiguousIndexError('integer labels')
+            is_int_index = _is_integer_index(self.frame.index)
 
+            idx = key
+            if _is_int_like(key) and not is_int_index:
                 idx = self.frame.index[key]
 
             if self.frame._is_mixed_type:
                 return self.frame.xs(idx)
             else:
+                # get a view if possible
                 return self.frame.xs(idx, copy=False)
         else:
             col = key
-            if isinstance(key, int):
-                if _is_integer_index(self.frame.columns):
-                    raise AmbiguousIndexError('integer labels')
+            if _is_int_like(key) and not _is_integer_index(self.frame.columns):
                 col = self.frame.columns[key]
-
             return self.frame[col]
 
     def _fancy_getitem(self, key, axis=0):
+        from pandas.core.series import Series
+
         labels = self.frame._get_axis(axis)
         axis_name = self.frame._get_axis_name(axis)
 
-        keyarr = np.asarray(key)
-
         # asarray can be unsafe, NumPy strings are weird
-        isbool = keyarr.dtype == np.bool_
-        if isbool:
+        keyarr = _asarray_tuplesafe(key)
+
+        if keyarr.dtype == np.bool_:
             if isinstance(key, Series):
                 if not key.index.equals(labels):
                     raise Exception('Cannot use boolean index with misaligned '
                                     'or unequal labels')
             return self.frame.reindex(**{axis_name : labels[np.asarray(key)]})
         else:
-            if _is_integer_dtype(keyarr) and _is_integer_index(labels):
-                raise AmbiguousIndexError('integer labels')
+            if _is_integer_dtype(keyarr) and not _is_integer_index(labels):
+                key = labels.take(keyarr)
 
             return self.frame.reindex(**{axis_name : key})
 
@@ -298,4 +291,24 @@ def crit(x):
 def _need_slice(obj):
     return obj.start is not None or obj.stop is not None
 
+def _maybe_droplevels(index, key):
+    # drop levels
+    if isinstance(key, tuple):
+        for _ in key:
+            index = index.droplevel(0)
+    else:
+        index = index.droplevel(0)
+
+    return index
+
+def _asarray_tuplesafe(values):
+    result = np.asarray(values)
+
+    if result.ndim == 2:
+        result = np.empty(len(values), dtype=object)
+        result[:] = values
+
+    return result
+
 _isboolarr = lambda x: np.asarray(x).dtype == np.bool_
+