Changed according to comments + other cleanups

pandas/core/frame.py

@@ -4626,7 +4626,7 @@ def sort_index(self, axis=0, level=None, ascending=True, inplace=False,
         elif isinstance(labels, MultiIndex):
             from pandas.core.sorting import lexsort_indexer
 
-            indexer = lexsort_indexer(labels._get_labels_for_sorting(),
+            indexer = lexsort_indexer(labels._get_codes_for_sorting(),
                                       orders=ascending,
                                       na_position=na_position)
         else:

pandas/core/indexes/multi.py

@@ -140,11 +140,13 @@ class MultiIndex(Index):
         The unique labels for each level
     codes : sequence of arrays
         Integers for each level designating which label at each location
+
+        .. versionadded:: 0.24.0
     labels : sequence of arrays
+        Integers for each level designating which label at each location
+
         .. deprecated:: 0.24.0
             Use ``codes`` instead
-
-        Integers for each level designating which label at each location
     sortorder : optional int
         Level of sortedness (must be lexicographically sorted by that
         level)
@@ -188,7 +190,6 @@ class MultiIndex(Index):
     names
     levels
     codes
-    labels
     nlevels
     levshape
 
@@ -199,7 +200,6 @@ class MultiIndex(Index):
     from_product
     set_levels
     set_codes
-    set_labels
     to_frame
     to_flat_index
     is_lexsorted
@@ -982,7 +982,7 @@ def dropna(self, how='any'):
         else:
             raise ValueError("invalid how option: {0}".format(how))
 
-        new_codes = [label[~indexer] for label in self.codes]
+        new_codes = [level_codes[~indexer] for level_codes in self.codes]
         return self.copy(codes=new_codes, deep=True)
 
     def get_value(self, series, key):
@@ -1123,15 +1123,15 @@ def format(self, space=2, sparsify=None, adjoin=True, names=False,
             return []
 
         stringified_levels = []
-        for lev, lab in zip(self.levels, self.codes):
+        for lev, level_codes in zip(self.levels, self.codes):
             na = na_rep if na_rep is not None else _get_na_rep(lev.dtype.type)
 
             if len(lev) > 0:
 
-                formatted = lev.take(lab).format(formatter=formatter)
+                formatted = lev.take(level_codes).format(formatter=formatter)
 
                 # we have some NA
-                mask = lab == -1
+                mask = level_codes == -1
                 if mask.any():
                     formatted = np.array(formatted, dtype=object)
                     formatted[mask] = na
@@ -1141,7 +1141,7 @@ def format(self, space=2, sparsify=None, adjoin=True, names=False,
                 # weird all NA case
                 formatted = [pprint_thing(na if isna(x) else x,
                                           escape_chars=('\t', '\r', '\n'))
-                             for x in algos.take_1d(lev._values, lab)]
+                             for x in algos.take_1d(lev._values, level_codes)]
             stringified_levels.append(formatted)
 
         result_levels = []
@@ -1661,11 +1661,11 @@ def __getitem__(self, key):
             key = com.cast_scalar_indexer(key)
 
             retval = []
-            for lev, lab in zip(self.levels, self.codes):
-                if lab[key] == -1:
+            for lev, level_codes in zip(self.levels, self.codes):
+                if level_codes[key] == -1:
                     retval.append(np.nan)
                 else:
-                    retval.append(lev[lab[key]])
+                    retval.append(lev[level_codes[key]])
 
             return tuple(retval)
         else:
@@ -1913,7 +1913,7 @@ def reorder_levels(self, order):
     def __getslice__(self, i, j):
         return self.__getitem__(slice(i, j))
 
-    def _get_labels_for_sorting(self):
+    def _get_codes_for_sorting(self):
         """
         we categorizing our codes by using the
         available categories (all, not just observed)
@@ -2739,26 +2739,26 @@ def equals(self, other):
             return False
 
         for i in range(self.nlevels):
-            slabels = self.codes[i]
-            slabels = slabels[slabels != -1]
-            svalues = algos.take_nd(np.asarray(self.levels[i]._values),
-                                    slabels, allow_fill=False)
-
-            olabels = other.codes[i]
-            olabels = olabels[olabels != -1]
-            ovalues = algos.take_nd(
+            self_codes = self.codes[i]
+            self_codes = self_codes[self_codes != -1]
+            self_values = algos.take_nd(np.asarray(self.levels[i]._values),
+                                        self_codes, allow_fill=False)
+
+            other_codes = other.codes[i]
+            other_codes = other_codes[other_codes != -1]
+            other_values = algos.take_nd(
                 np.asarray(other.levels[i]._values),
-                olabels, allow_fill=False)
+                other_codes, allow_fill=False)
 
             # since we use NaT both datetime64 and timedelta64
             # we can have a situation where a level is typed say
             # timedelta64 in self (IOW it has other values than NaT)
             # but types datetime64 in other (where its all NaT)
             # but these are equivalent
-            if len(svalues) == 0 and len(ovalues) == 0:
+            if len(self_values) == 0 and len(other_values) == 0:
                 continue
 
-            if not array_equivalent(svalues, ovalues):
+            if not array_equivalent(self_values, other_values):
                 return False
 
         return True
@@ -2920,7 +2920,7 @@ def insert(self, loc, item):
             if k not in level:
                 # have to insert into level
                 # must insert at end otherwise you have to recompute all the
-                # other labels
+                # other codes
                 lev_loc = len(level)
                 level = level.insert(lev_loc, k)
             else:
@@ -2958,13 +2958,13 @@ def isin(self, values, level=None):
         else:
             num = self._get_level_number(level)
             levs = self.levels[num]
-            labs = self.codes[num]
+            level_codes = self.codes[num]
 
             sought_labels = levs.isin(values).nonzero()[0]
             if levs.size == 0:
-                return np.zeros(len(labs), dtype=np.bool_)
+                return np.zeros(len(level_codes), dtype=np.bool_)
             else:
-                return np.lib.arraysetops.in1d(labs, sought_labels)
+                return np.lib.arraysetops.in1d(level_codes, sought_labels)
 
 
 MultiIndex._add_numeric_methods_disabled()

pandas/core/series.py

@@ -2730,7 +2730,7 @@ def sort_index(self, axis=0, level=None, ascending=True, inplace=False,
         elif isinstance(index, MultiIndex):
             from pandas.core.sorting import lexsort_indexer
             labels = index._sort_levels_monotonic()
-            indexer = lexsort_indexer(labels._get_labels_for_sorting(),
+            indexer = lexsort_indexer(labels._get_codes_for_sorting(),
                                       orders=ascending,
                                       na_position=na_position)
         else: