ENH: MultiIndex.from_frame

pandas/core/indexes/multi.py

@@ -1189,11 +1189,11 @@ def to_frame(self, index=True, name=None):
         else:
             idx_names = self.names
 
-        result = DataFrame({(name or level):
-                            self._get_level_values(level)
-                            for name, level in
-                            zip(idx_names, range(len(self.levels)))},
-                           copy=False)
+        result = DataFrame(
+            list(self),
+            columns=[n or i for i, n in enumerate(idx_names)]
+        )
+
         if index:
             result.index = self
         return result
@@ -1412,6 +1412,45 @@ def from_product(cls, iterables, sortorder=None, names=None):
         labels = cartesian_product(labels)
         return MultiIndex(levels, labels, sortorder=sortorder, names=names)
 
+    @classmethod
+    def from_frame(cls, df, squeeze=True):
+        """
+        Make a MultiIndex from a dataframe
+
+        Parameters
+        ----------
+        df : pd.DataFrame
+            DataFrame to be converted to MultiIndex
+        squeeze : bool
+            If df is a single column, squeeze multiindex to be a regular index.
+
+        Returns
+        -------
+        index : MultiIndex
+
+        Examples
+        --------
+        >>> df = pd.DataFrame([[0, u'green'], [0, u'purple'], [1, u'green'],
+                               [1, u'purple'], [2, u'green'], [2, u'purple']],
+                              columns=[u'number', u'color'])
+        >>> pd.MultiIndex.from_frame(df)
+        MultiIndex(levels=[[0, 1, 2], [u'green', u'purple']],
+                   labels=[[0, 0, 1, 1, 2, 2], [0, 1, 0, 1, 0, 1]],
+                   names=[u'number', u'color'])
+
+        """
+        from pandas import DataFrame
+        # just let column level names be the tuple of the meta df columns
+        # since they're not required to be strings
+        if not isinstance(df, DataFrame):
+            raise TypeError("Input must be a DataFrame")
+        columns = list(df)
+        mi = cls.from_tuples(list(df.values), names=columns)
+        if squeeze:
+            return mi.squeeze()
+        else:
+            return mi
+
     def _sort_levels_monotonic(self):
         """
         .. versionadded:: 0.20.0
@@ -1474,6 +1513,28 @@ def _sort_levels_monotonic(self):
                           names=self.names, sortorder=self.sortorder,
                           verify_integrity=False)
 
+    def squeeze(self):
+        """
+        Squeeze a single level multiindex to be a regular Index instane. If
+        the MultiIndex is more than a single level, return a copy of the
+        MultiIndex.
+
+        Returns
+        -------
+        index : Index | MultiIndex
+
+        Examples
+        --------
+        >>> mi = pd.MultiIndex.from_tuples([('a',), ('b',), ('c',)])
+        >>> mi.squeeze()
+        Index(['a', 'b', 'c'], dtype='object')
+
+        """
+        if len(self.levels) == 1:
+            return self.levels[0][self.labels[0]]
+        else:
+            return self.copy()
+
     def remove_unused_levels(self):
         """
         Create a new MultiIndex from the current that removes

pandas/tests/indexes/multi/test_constructor.py

@@ -472,3 +472,45 @@ def test_from_tuples_with_tuple_label():
     idx = pd.MultiIndex.from_tuples([(2, 1), (4, (1, 2))], names=('a', 'b'))
     result = pd.DataFrame([2, 3], columns=['c'], index=idx)
     tm.assert_frame_equal(expected, result)
+
+
+def test_from_frame():
+    expected = pd.MultiIndex.from_tuples([('a', 'a'), ('a', 'b'), ('a', 'c'),
+                                          ('b', 'a'), ('b', 'b'), ('c', 'a'),
+                                          ('c', 'b')],
+                                         names=['L1', 'L2'])
+    df = pd.DataFrame([['a', 'a'], ['a', 'b'], ['a', 'c'], ['b', 'a'],
+                       ['b', 'b'], ['c', 'a'], ['c', 'b']],
+                      columns=['L1', 'L2'])
+    result = pd.MultiIndex.from_frame(df)
+    tm.assert_index_equal(expected, result)
+
+
+def test_from_frame():
+    df = pd.DataFrame([['a', 'a'], ['a', 'b'], ['b', 'a'], ['b', 'b']],
+                      columns=['L1', 'L2'])
+    expected = pd.MultiIndex.from_tuples([('a', 'a'), ('a', 'b'),
+                                          ('b', 'a'), ('b', 'b')],
+                                         names=['L1', 'L2'])
+    result = pd.MultiIndex.from_frame(df)
+    tm.assert_index_equal(expected, result)
+
+
+def test_from_frame_with_squeeze():
+    df = pd.DataFrame([['a'], ['a'], ['b'], ['b']], columns=['L1'])
+    expected = pd.Index(['a', 'a', 'b', 'b'], name='L1')
+    result = pd.MultiIndex.from_frame(df)
+    tm.assert_index_equal(expected, result)
+
+
+def test_from_frame_with_no_squeeze():
+    df = pd.DataFrame([['a'], ['a'], ['b'], ['b']], columns=['L1'])
+    expected = pd.MultiIndex.from_tuples([('a',), ('a',), ('b',), ('b',)],
+                                         names=['L1'])
+    result = pd.MultiIndex.from_frame(df, squeeze=False)
+    tm.assert_index_equal(expected, result)
+
+
+def test_from_frame_non_frame():
+    with pytest.raises(TypeError):
+        pd.MultiIndex.from_frame([1, 2, 3, 4])

pandas/tests/indexes/multi/test_conversion.py

@@ -169,3 +169,18 @@ def test_to_series_with_arguments(idx):
     assert s.values is not idx.values
     assert s.index is not idx
     assert s.name != idx.name
+
+
+def test_squeeze():
+    mi = pd.MultiIndex.from_tuples([('a',), ('a',), ('b',), ('b',)],
+                                   names=['L1'])
+    expected = pd.Index(['a', 'a', 'b', 'b'], name='L1')
+    result = mi.squeeze()
+    tm.assert_index_equal(expected, result)
+
+    mi = pd.MultiIndex.from_tuples([('a', 'a'), ('a', 'b'), ('b', 'a'),
+                                   ('b', 'b')],
+                                   names=['L1', 'L2'])
+    expected = mi.copy()
+    result = mi.squeeze()
+    tm.assert_index_equal(expected, result)