don't show useless dtype in repr

Author: topper-123

doc/source/whatsnew/v0.25.0.rst

@@ -35,14 +35,14 @@ The repr now looks like this:
    pd.MultiIndex.from_product([['a', 'abc'], range(500)])
 
 Previously, outputting a :class:`MultiIndex` printed all the ``levels`` and
-``labels`` of the ``MultiIndex``, which was visually unappealing and made
+``codes`` of the ``MultiIndex``, which was visually unappealing and made
 the output more difficult to navigate:
 
 .. code-block:: ipython
 
-   >>>pd.MultiIndex.from_product([['a', 'abc'], range(5)])
-   MultiIndex(levels=[['a', 'abc'], [0, 1, 2, 3]],
-              labels=[[0, 0, 0, 0, 1, 1, 1, 1], [0, 1, 2, 3, 0, 1, 2, 3]])
+   In [1]: pd.MultiIndex.from_product([['a', 'abc'], range(5)])
+   Out[1]: MultiIndex(levels=[['a', 'abc'], [0, 1, 2, 3]],
+      ...:            codes=[[0, 0, 0, 0, 1, 1, 1, 1], [0, 1, 2, 3, 0, 1, 2, 3]])
 
 In the new repr, all values will be shown, if the number of rows is smaller
 than :attr:`options.display.max_seq_items` (default: 100 items). Horizontally,

pandas/core/indexes/base.py

@@ -1306,20 +1306,20 @@ def set_names(self, names, level=None, inplace=False):
                     ('python', 2019),
                     ( 'cobra', 2018),
                     ( 'cobra', 2019)],
-                   dtype='object')
+                   )
         >>> idx.set_names(['kind', 'year'], inplace=True)
         >>> idx
         MultiIndex([('python', 2018),
                     ('python', 2019),
                     ( 'cobra', 2018),
                     ( 'cobra', 2019)],
-                   dtype='object', names=['kind', 'year'])
+                   names=['kind', 'year'])
         >>> idx.set_names('species', level=0)
         MultiIndex([('python', 2018),
                     ('python', 2019),
                     ( 'cobra', 2018),
                     ( 'cobra', 2019)],
-                   dtype='object', names=['species', 'year'])
+                   names=['species', 'year'])
         """
 
         if level is not None and not isinstance(self, ABCMultiIndex):
@@ -1384,13 +1384,13 @@ def rename(self, name, inplace=False):
                     ('python', 2019),
                     ( 'cobra', 2018),
                     ( 'cobra', 2019)],
-                   dtype='object', names=['kind', 'year'])
+                   names=['kind', 'year'])
         >>> idx.rename(['species', 'year'])
         MultiIndex([('python', 2018),
                     ('python', 2019),
                     ( 'cobra', 2018),
                     ( 'cobra', 2019)],
-                   dtype='object', names=['species', 'year'])
+                   names=['species', 'year'])
         >>> idx.rename('species')
         Traceback (most recent call last):
         TypeError: Must pass list-like as `names`.
@@ -5311,7 +5311,7 @@ def ensure_index_from_sequences(sequences, names=None):
                                     names=['L1', 'L2'])
     MultiIndex([('a', 'a'),
                 ('a', 'b')],
-               dtype='object', names=['L1', 'L2'])
+               names=['L1', 'L2'])
 
     See Also
     --------
@@ -5350,14 +5350,9 @@ def ensure_index(index_like, copy=False):
     Index([('a', 'a'), ('b', 'c')], dtype='object')
 
     >>> ensure_index([['a', 'a'], ['b', 'c']])
-<<<<<<< HEAD
-    MultiIndex(levels=[['a'], ['b', 'c']],
-               codes=[[0, 0], [0, 1]])
-=======
     MultiIndex([('a', 'b'),
                 ('a', 'c')],
-               dtype='object')
->>>>>>> Improve docs
+               )
 
     See Also
     --------

pandas/core/indexes/multi.py

@@ -30,7 +30,8 @@
 from pandas.core.indexes.frozen import FrozenList, _ensure_frozen
 import pandas.core.missing as missing
 
-from pandas.io.formats.printing import format_object_summary, pprint_thing
+from pandas.io.formats.printing import (
+    format_object_attrs, format_object_summary, pprint_thing)
 
 _index_doc_kwargs = dict(ibase._index_doc_kwargs)
 _index_doc_kwargs.update(
@@ -188,8 +189,10 @@ class MultiIndex(Index):
 
     >>> arrays = [[1, 1, 2, 2], ['red', 'blue', 'red', 'blue']]
     >>> pd.MultiIndex.from_arrays(arrays, names=('number', 'color'))
-    MultiIndex(levels=[[1, 2], ['blue', 'red']],
-               codes=[[0, 0, 1, 1], [1, 0, 1, 0]],
+    MultiIndex([(1,  'red'),
+                (1, 'blue'),
+                (2,  'red'),
+                (2, 'blue')],
                names=['number', 'color'])
 
     See further examples for how to construct a MultiIndex in the doc strings
@@ -319,8 +322,10 @@ def from_arrays(cls, arrays, sortorder=None, names=None):
         --------
         >>> arrays = [[1, 1, 2, 2], ['red', 'blue', 'red', 'blue']]
         >>> pd.MultiIndex.from_arrays(arrays, names=('number', 'color'))
-        MultiIndex(levels=[[1, 2], ['blue', 'red']],
-                   codes=[[0, 0, 1, 1], [1, 0, 1, 0]],
+        MultiIndex([(1,  'red'),
+                    (1, 'blue'),
+                    (2,  'red'),
+                    (2, 'blue')],
                    names=['number', 'color'])
         """
         error_msg = "Input must be a list / sequence of array-likes."
@@ -384,7 +389,7 @@ def from_tuples(cls, tuples, sortorder=None, names=None):
                     (1, 'blue'),
                     (2,  'red'),
                     (2, 'blue')],
-                   dtype='object', names=['number', 'color'])
+                   names=['number', 'color'])
         """
         if not is_list_like(tuples):
             raise TypeError('Input must be a list / sequence of tuple-likes.')
@@ -445,7 +450,7 @@ def from_product(cls, iterables, sortorder=None, names=None):
                     (1, 'purple'),
                     (2,  'green'),
                     (2, 'purple')],
-                   dtype='object', names=['number', 'color'])
+                   names=['number', 'color'])
         """
         from pandas.core.arrays.categorical import _factorize_from_iterables
         from pandas.core.reshape.util import cartesian_product
@@ -503,15 +508,19 @@ def from_frame(cls, df, sortorder=None, names=None):
         3    NJ  Precip
 
         >>> pd.MultiIndex.from_frame(df)
-        MultiIndex(levels=[['HI', 'NJ'], ['Precip', 'Temp']],
-                   codes=[[0, 0, 1, 1], [1, 0, 1, 0]],
+        MultiIndex([('HI',   'Temp'),
+                    ('HI', 'Precip'),
+                    ('NJ',   'Temp'),
+                    ('NJ', 'Precip')],
                    names=['a', 'b'])
 
         Using explicit names, instead of the column names
 
         >>> pd.MultiIndex.from_frame(df, names=['state', 'observation'])
-        MultiIndex(levels=[['HI', 'NJ'], ['Precip', 'Temp']],
-                   codes=[[0, 0, 1, 1], [1, 0, 1, 0]],
+        MultiIndex([('HI',   'Temp'),
+                    ('HI', 'Precip'),
+                    ('NJ',   'Temp'),
+                    ('NJ', 'Precip')],
                    names=['state', 'observation'])
         """
         if not isinstance(df, ABCDataFrame):
@@ -628,49 +637,30 @@ def set_levels(self, levels, level=None, inplace=False,
         >>> idx = pd.MultiIndex.from_tuples([(1, 'one'), (1, 'two'),
                                             (2, 'one'), (2, 'two')],
                                             names=['foo', 'bar'])
-<<<<<<< HEAD
-        >>> idx.set_levels([['a','b'], [1,2]])
-        MultiIndex(levels=[['a', 'b'], [1, 2]],
-                   codes=[[0, 0, 1, 1], [0, 1, 0, 1]],
-                   names=['foo', 'bar'])
-        >>> idx.set_levels(['a','b'], level=0)
-        MultiIndex(levels=[['a', 'b'], ['one', 'two']],
-                   codes=[[0, 0, 1, 1], [0, 1, 0, 1]],
-                   names=['foo', 'bar'])
-        >>> idx.set_levels(['a','b'], level='bar')
-        MultiIndex(levels=[[1, 2], ['a', 'b']],
-                   codes=[[0, 0, 1, 1], [0, 1, 0, 1]],
-                   names=['foo', 'bar'])
-        >>> idx.set_levels([['a','b'], [1,2]], level=[0,1])
-        MultiIndex(levels=[['a', 'b'], [1, 2]],
-                   codes=[[0, 0, 1, 1], [0, 1, 0, 1]],
-                   names=['foo', 'bar'])
-=======
         >>> idx.set_levels([['a', 'b'], [1, 2]])
         MultiIndex([('a', 1),
                     ('a', 2),
                     ('b', 1),
                     ('b', 2)],
-                   dtype='object', names=['foo', 'bar'])
+                   names=['foo', 'bar'])
         >>> idx.set_levels(['a', 'b'], level=0)
         MultiIndex([('a', 'one'),
                     ('a', 'two'),
                     ('b', 'one'),
                     ('b', 'two')],
-                   dtype='object', names=['foo', 'bar'])
+                   names=['foo', 'bar'])
         >>> idx.set_levels(['a', 'b'], level='bar')
         MultiIndex([(1, 'a'),
                     (1, 'b'),
                     (2, 'a'),
                     (2, 'b')],
-                   dtype='object', names=['foo', 'bar'])
+                   names=['foo', 'bar'])
         >>> idx.set_levels([['a', 'b'], [1, 2]], level=[0, 1])
         MultiIndex([('a', 1),
                     ('a', 2),
                     ('b', 1),
                     ('b', 2)],
-                   dtype='object', names=['foo', 'bar'])
->>>>>>> Update doc string examples and docs
+                   names=['foo', 'bar'])
         """
         if is_list_like(levels) and not isinstance(levels, Index):
             levels = list(levels)
@@ -797,26 +787,30 @@ def set_codes(self, codes, level=None, inplace=False,
                     (1, 'one'),
                     (2, 'two'),
                     (1, 'two')],
-                   dtype='object', names=['foo', 'bar'])
+                   names=['foo', 'bar'])
         >>> idx.set_codes([1, 0, 1, 0], level=0)
         MultiIndex([(2, 'one'),
                     (1, 'two'),
                     (2, 'one'),
                     (1, 'two')],
-                   dtype='object', names=['foo', 'bar'])
+                   names=['foo', 'bar'])
         >>> idx.set_codes([0, 0, 1, 1], level='bar')
         MultiIndex([(1, 'one'),
                     (1, 'one'),
                     (2, 'two'),
                     (2, 'two')],
-                   dtype='object', names=['foo', 'bar'])
+                   names=['foo', 'bar'])
         >>> idx.set_codes([[1, 0, 1, 0], [0, 0, 1, 1]], level=[0, 1])
         MultiIndex([(2, 'one'),
                     (1, 'one'),
                     (2, 'two'),
                     (1, 'two')],
+<<<<<<< HEAD
                    dtype='object', names=['foo', 'bar'])
 >>>>>>> Update doc string examples and docs
+=======
+                   names=['foo', 'bar'])
+>>>>>>> don't show useless dtype in repr
         """
         if level is not None and not is_list_like(level):
             if not is_list_like(codes):
@@ -980,6 +974,12 @@ def _format_data(self, name=None):
         return format_object_summary(self, self._formatter_func,
                                      name=name, line_break_each_value=True)
 
+    def _format_attrs(self):
+        """
+        Return a list of tuples of the (attr,formatted_value).
+        """
+        return format_object_attrs(self, include_dtype=False)
+
     def _format_native_types(self, na_rep='nan', **kwargs):
         new_levels = []
         new_codes = []
@@ -1575,7 +1575,7 @@ def to_hierarchical(self, n_repeat, n_shuffle=1):
                     (2, 'two'),
                     (2, 'two'),
                     (2, 'two')],
-                   dtype='object')
+                   )
         """
         levels = self.levels
         codes = [np.repeat(level_codes, n_repeat) for
@@ -1669,14 +1669,14 @@ def _sort_levels_monotonic(self):
                     ('a', 'aa'),
                     ('b', 'bb'),
                     ('b', 'aa')],
-                   dtype='object')
+                   )
 
         >>> mi.sort_values()
         MultiIndex([('a', 'aa'),
                     ('a', 'bb'),
                     ('b', 'aa'),
                     ('b', 'bb')],
-                   dtype='object')
+                   )
         """
 
         if self.is_lexsorted() and self.is_monotonic:
@@ -1731,12 +1731,12 @@ def remove_unused_levels(self):
                     (0, 'b'),
                     (1, 'a'),
                     (1, 'b')],
-                   dtype='object')
+                   )
 
         >>> mi[2:]
         MultiIndex([(1, 'a'),
                     (1, 'b')],
-                   dtype='object')
+                   )
 
         The 0 from the first level is not represented
         and can be removed
@@ -2053,12 +2053,13 @@ def swaplevel(self, i=-2, j=-1):
                     ('a', 'aa'),
                     ('b', 'bb'),
                     ('b', 'aa')],
-                   dtype='object')
+                   )
         >>> mi.swaplevel(0, 1)
         MultiIndex([('bb', 'a'),
                     ('aa', 'a'),
                     ('bb', 'b'),
                     ('aa', 'b')],
+                   )
         """
         new_levels = list(self.levels)
         new_codes = list(self.codes)

pandas/io/formats/printing.py

@@ -468,7 +468,7 @@ def _justify(head, tail):
     return head, tail
 
 
-def format_object_attrs(obj):
+def format_object_attrs(obj, include_dtype=True):
     """
     Return a list of tuples of the (attr, formatted_value)
     for common attrs, including dtype, name, length
@@ -477,14 +477,16 @@ def format_object_attrs(obj):
     ----------
     obj : object
         must be iterable
+    include_dtype : bool
+        If False, dtype won't be in the returned list
 
     Returns
     -------
     list
 
     """
     attrs = []
-    if hasattr(obj, 'dtype'):
+    if hasattr(obj, 'dtype') and include_dtype:
         attrs.append(('dtype', "'{}'".format(obj.dtype)))
     if getattr(obj, 'name', None) is not None:
         attrs.append(('name', default_pprint(obj.name)))