Give user-friendly exceptions

Author: Xbar

doc/source/whatsnew/v0.22.0.txt

@@ -138,6 +138,7 @@ Indexing
 - Bug in :func:`Series.truncate` which raises ``TypeError`` with a monotonic ``PeriodIndex`` (:issue:`17717`)
 - Bug in :func:`DataFrame.groupby` where tuples were interpreted as lists of keys rather than as keys (:issue:`17979`, :issue:`18249`)
 - Bug in :func:`MultiIndex.remove_unused_levels`` which would fill nan values (:issue:`18417`)
+- Bug in :func:`MultiIndex.from_tuples`` which would fail to take zipped tuples in python3 (:issue:`18434`)
 - Bug in :class:`IntervalIndex` where empty and purely NA data was constructed inconsistently depending on the construction method (:issue:`18421`)
 -
 

pandas/core/indexes/multi.py

@@ -1162,6 +1162,11 @@ def from_arrays(cls, arrays, sortorder=None, names=None):
         MultiIndex.from_product : Make a MultiIndex from cartesian product
                                   of iterables
         """
+        if not is_list_like(arrays):
+            raise TypeError("Input must be a list / sequence of array-likes.")
+        elif is_iterator(arrays):
+            arrays = list(arrays)
+
         # Check if lengths of all arrays are equal or not,
         # raise ValueError, if not
         for i in range(1, len(arrays)):
@@ -1206,6 +1211,11 @@ def from_tuples(cls, tuples, sortorder=None, names=None):
         MultiIndex.from_product : Make a MultiIndex from cartesian product
                                   of iterables
         """
+        if not is_list_like(tuples):
+            raise TypeError('Input must be a list /sequence of tuple-likes.')
+        elif is_iterator(tuples):
+            tuples = list(tuples)
+
         if len(tuples) == 0:
             if names is None:
                 msg = 'Cannot infer number of levels from empty list'
@@ -1260,6 +1270,11 @@ def from_product(cls, iterables, sortorder=None, names=None):
         from pandas.core.categorical import _factorize_from_iterables
         from pandas.core.reshape.util import cartesian_product
 
+        if not is_list_like(iterables):
+            raise TypeError("Input must be a list / sequence of iterables.")
+        elif is_iterator(iterables):
+            iterables = list(iterables)
+
         labels, levels = _factorize_from_iterables(iterables)
         labels = cartesian_product(labels)
         return MultiIndex(levels, labels, sortorder=sortorder, names=names)
@@ -1365,29 +1380,31 @@ def remove_unused_levels(self):
         new_labels = []
 
         changed = False
-        for lev, lab in zip(self.levels, self.labels):
+        for idx, (lev, lab) in enumerate(zip(self.levels, self.labels)):
+            na_idxs = np.where(lab == -1)[0]
+
+            if len(na_idxs):
+                lab = np.delete(lab, na_idxs)
 
             uniques = algos.unique(lab)
-            na_idx = np.where(uniques == -1)[0]
 
             # nothing unused
-            if len(uniques) != len(lev) + len(na_idx):
+            if len(uniques) != len(lev):
                 changed = True
 
-                if len(na_idx):
-                    # Just ensure that -1 is in first position:
-                    uniques[[0, na_idx[0]]] = uniques[[na_idx[0], 0]]
-
                 # labels get mapped from uniques to 0:len(uniques)
-                # -1 (if present) is mapped to last position
-                label_mapping = np.zeros(len(lev) + len(na_idx))
-                # ... and reassigned value -1:
-                label_mapping[uniques] = np.arange(len(uniques)) - len(na_idx)
+                label_mapping = np.zeros(len(lev))
+                label_mapping[uniques] = np.arange(len(uniques))
 
                 lab = label_mapping[lab]
 
                 # new levels are simple
-                lev = lev.take(uniques[len(na_idx):])
+                lev = lev.take(uniques)
+
+                if len(na_idxs):
+                    lab = np.insert(lab, na_idxs - np.arange(len(na_idxs)), -1)
+            else:
+                lab = self.labels[idx]
 
             new_levels.append(lev)
             new_labels.append(lab)

pandas/tests/indexes/test_multi.py

@@ -672,9 +672,19 @@ def test_from_arrays(self):
         for lev, lab in zip(self.index.levels, self.index.labels):
             arrays.append(np.asarray(lev).take(lab))
 
+        # list of arrays as input
         result = MultiIndex.from_arrays(arrays)
         assert list(result) == list(self.index)
 
+        # iterator as input
+        result2 = MultiIndex.from_arrays(iter(arrays))
+        assert list(result2) == list(self.index)
+
+        # invlide iterator input
+        with tm.assert_raises_regex(
+                TypeError, "Input must be a list / sequence of array-likes."):
+            MultiIndex.from_arrays(0)
+
         # infer correctly
         result = MultiIndex.from_arrays([[pd.NaT, Timestamp('20130101')],
                                          ['a', 'b']])
@@ -827,6 +837,16 @@ def test_from_product(self):
         tm.assert_index_equal(result, expected)
         assert result.names == names
 
+        # iterator as input
+        result2 = MultiIndex.from_product(iter([first, second]), names=names)
+        assert result2.equals(expected)
+        assert result2.names == names
+
+        # Invalid non-iterable input
+        with tm.assert_raises_regex(
+                TypeError, "Input must be a list / sequence of iterables."):
+            MultiIndex.from_product(0)
+
     def test_from_product_empty(self):
         # 0 levels
         with tm.assert_raises_regex(
@@ -1725,8 +1745,24 @@ def test_from_tuples(self):
                                'from empty list',
                                MultiIndex.from_tuples, [])
 
-        idx = MultiIndex.from_tuples(((1, 2), (3, 4)), names=['a', 'b'])
-        assert len(idx) == 2
+        expected = MultiIndex(levels=[[1, 3], [2, 4]],
+                              labels=[[0, 1], [0, 1]],
+                              names=['a', 'b'])
+
+        # input tuples
+        res1 = MultiIndex.from_tuples(((1, 2), (3, 4)), names=['a', 'b'])
+        assert expected.names == res1.names
+        assert res1.equals(expected)
+
+        # input iterator for tuples
+        res2 = MultiIndex.from_tuples(zip([1, 3], [2, 4]), names=['a', 'b'])
+        assert expected.names == res2.names
+        assert res2.equals(expected)
+
+        # input non-iterables
+        with tm.assert_raises_regex(
+                TypeError, 'Input must be a list /sequence of tuple-likes.'):
+            MultiIndex.from_tuples(0)
 
     def test_from_tuples_empty(self):
         # GH 16777