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
@@ -1294,6 +1294,7 @@ def from_arrays(cls, arrays, sortorder=None, names=None):
         MultiIndex.from_tuples : Convert list of tuples to MultiIndex
         MultiIndex.from_product : Make a MultiIndex from cartesian product
                                   of iterables
+        MultiIndex.from_frame : Make a MultiIndex from a DataFrame.
         """
         if not is_list_like(arrays):
             raise TypeError("Input must be a list / sequence of array-likes.")
@@ -1343,6 +1344,7 @@ def from_tuples(cls, tuples, sortorder=None, names=None):
         MultiIndex.from_arrays : Convert list of arrays to MultiIndex
         MultiIndex.from_product : Make a MultiIndex from cartesian product
                                   of iterables
+        MultiIndex.from_frame : Make a MultiIndex from a DataFrame.
         """
         if not is_list_like(tuples):
             raise TypeError('Input must be a list / sequence of tuple-likes.')
@@ -1399,6 +1401,7 @@ def from_product(cls, iterables, sortorder=None, names=None):
         --------
         MultiIndex.from_arrays : Convert list of arrays to MultiIndex
         MultiIndex.from_tuples : Convert list of tuples to MultiIndex
+        MultiIndex.from_frame : Make a MultiIndex from a DataFrame.
         """
         from pandas.core.arrays.categorical import _factorize_from_iterables
         from pandas.core.reshape.util import cartesian_product
@@ -1412,6 +1415,61 @@ 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, default True
+            If df is a single column, squeeze multiindex to be a regular index.
+
+        Returns
+        -------
+        MultiIndex or Index
+            The MultiIndex representation of the given DataFrame. Returns an
+            Index if the DataFrame is single column and squeeze is True.
+
+        Examples
+        --------
+        >>> df = pd.DataFrame([[0, 'green'], [0, 'purple'], [1, 'green'],
+        ...                    [1, 'purple'], [2, 'green'], [2, 'purple']],
+        ...                   columns=['number', 'color'])
+        >>> df
+           number   color
+        0       0   green
+        1       0  purple
+        2       1   green
+        3       1  purple
+        4       2   green
+        5       2  purple
+        >>> pd.MultiIndex.from_frame(df)
+        MultiIndex(levels=[[0, 1, 2], ['green', 'purple']],
+                   labels=[[0, 0, 1, 1, 2, 2], [0, 1, 0, 1, 0, 1]],
+                   names=['number', 'color'])
+
+        See Also
+        --------
+        MultiIndex.from_arrays : Convert list of arrays to MultiIndex
+        MultiIndex.from_tuples : Convert list of tuples to MultiIndex
+        MultiIndex.from_product : Make a MultiIndex from cartesian product
+                                  of iterables
+        """
+        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 +1532,27 @@ 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.
+
+        Returns
+        -------
+        Index or MultiIndex
+            Returns Index equivalent of single level MultiIndex. Returns
+            copy of MultiIndex if multilevel.
+
+        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)