ENH: Provide dict object for to_dict() pandas-dev#16122

Author: dwkenefick

pandas/core/common.py

@@ -481,43 +481,39 @@ def _dict_compat(d):
                 for key, value in iteritems(d))
 
 
-def prep_maping_for_to_dict(into):
+def standardize_mapping(into):
     """
-    Helper function to standardize the supplied mapping so it can
-    be passed to the ``Series.to_dict()`` and ``DataFrame.to_dict()``
-    
+    Helper function to standardize a supplied mapping.
     .. versionadded:: 0.21.0
 
     Parameters
     ----------
     into : instance or subclass of collections.Mapping
-        The argument supplied to ``to_dict``.  Must be a class, an
-        initialized collections.defaultdict, or an empty instance
-        of a collections.Mapping subclass.
+        Must be a class, an initialized collections.defaultdict,
+        or an empty instance of a collections.Mapping subclass.
 
     Returns
     -------
     mapping : a collections.Mapping subclass or other constructor
         a callable object that can accept an iterator to create
         the desired Mapping.
 
+    See Also
+    --------
+    DataFrame.to_dict
+    Series.to_dict
     """
     if not inspect.isclass(into):
-        if len(into) > 0:
-            raise ValueError(
-                "to_dict() only accepts empty mappings.")
-        elif isinstance(into, collections.defaultdict):
+        if isinstance(into, collections.defaultdict):
             return partial(
                 collections.defaultdict, into.default_factory)
-        else:
-            return prep_maping_for_to_dict(type(into))
-    elif not issubclass(into, collections.Mapping):
+        into = type(into)
+    if not issubclass(into, collections.Mapping):
         raise TypeError('unsupported type: {}'.format(into))
     elif into == collections.defaultdict:
         raise TypeError(
             'to_dict() only accepts initialized defaultdicts')
-    else:
-        return into
+    return into
 
 
 def sentinel_factory():

pandas/core/frame.py

@@ -64,7 +64,7 @@
                                 _values_from_object,
                                 _maybe_box_datetimelike,
                                 _dict_compat,
-                                prep_maping_for_to_dict)
+                                standardize_mapping)
 from pandas.core.generic import NDFrame, _shared_docs
 from pandas.core.index import Index, MultiIndex, _ensure_index
 from pandas.core.indexing import (maybe_droplevels, convert_to_index_sliceable,
@@ -889,29 +889,30 @@ def to_dict(self, orient='dict', into=dict):
             instance of the mapping type you want.  If you want a
             collections.defaultdict, you must pass an initialized
             instance.
-            
+
             .. versionadded:: 0.21.0
 
         Returns
         -------
         result : collections.Mapping like {column -> {index -> value}}
             If ``into`` is collections.defaultdict, the return
             value's default_factory will be None.
-            
+
         Examples
         --------
         >>> from pandas import DataFrame
         >>> from collections import OrderedDict, defaultdict
-        >>> df = DataFrame({'col1': [1, 2], 'col2': [0.5, 0.75]}, index=['a', 'b'])
+        >>> df = DataFrame(
+                {'col1': [1, 2], 'col2': [0.5, 0.75]}, index=['a', 'b'])
         >>> df
            col1  col2
         a     1   0.1
         b     2   0.2
         >>> df.to_dict()
         {'col1': {'a': 1, 'b': 2}, 'col2': {'a': 0.5, 'b': 0.75}}
-        
+
         You can specify the return orientation.
-        
+
         >>> df.to_dict('series')
         {'col1': a    1
         b    2
@@ -926,22 +927,25 @@ def to_dict(self, orient='dict', into=dict):
         [{'col1': 1.0, 'col2': 0.5}, {'col1': 2.0, 'col2': 0.75}]
         >>> df.to_dict('index')
         {'a': {'col1': 1.0, 'col2': 0.5}, 'b': {'col1': 2.0, 'col2': 0.75}}
-        
-        You can also specify the mapping type.  
-        
+
+        You can also specify the mapping type.
+
         >>> df.to_dict(into=OrderedDict)
-        OrderedDict([('col2', OrderedDict([('a', 0.5), ('b', 0.75)])),
-                     ('col1', OrderedDict([('a', 1), ('b', 2)]))])
+        OrderedDict([('col1', OrderedDict([('a', 1), ('b', 2)])),
+                   ('col2', OrderedDict([('a', 0.5), ('b', 0.75)]))])
+
+        If you want a `defaultdict`, you need to initialize it:
+
         >>> dd = defaultdict(list)
         >>> df.to_dict('records', into=dd)
-        [defaultdict(list, {'col1': 1.0, 'col2': 0.5}),
-         defaultdict(list, {'col1': 2.0, 'col2': 0.75})]        
+        [defaultdict(<type 'list'>, {'col2': 0.5, 'col1': 1.0}),
+        defaultdict(<type 'list'>, {'col2': 0.75, 'col1': 2.0})]
         """
         if not self.columns.is_unique:
             warnings.warn("DataFrame columns are not unique, some "
                           "columns will be omitted.", UserWarning)
         # GH16122
-        into_c = prep_maping_for_to_dict(into)
+        into_c = standardize_mapping(into)
         if orient.lower().startswith('d'):
             return into_c(
                 (k, v.to_dict(into)) for k, v in compat.iteritems(self))

pandas/core/series.py

@@ -47,7 +47,7 @@
                                 SettingWithCopyError,
                                 _maybe_box_datetimelike,
                                 _dict_compat,
-                                prep_maping_for_to_dict)
+                                standardize_mapping)
 from pandas.core.index import (Index, MultiIndex, InvalidIndexError,
                                Float64Index, _ensure_index)
 from pandas.core.indexing import check_bool_indexer, maybe_convert_indices
@@ -1085,15 +1085,15 @@ def to_dict(self, into=dict):
             object. Can be the actual class or an empty
             instance of the mapping type you want.  If you want a
             collections.defaultdict, you must pass an initialized
-            
+
             .. versionadded:: 0.21.0
 
         Returns
         -------
         value_dict : collections.Mapping
             If ``into`` is collections.defaultdict, the return
             value's default_factory will be None.
-            
+
         Examples
         --------
         >>> from pandas import Series
@@ -1105,11 +1105,10 @@ def to_dict(self, into=dict):
         OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
         >>> dd = defaultdict(list)
         >>> s.to_dict(dd)
-        defaultdict(list, {0: 1, 1: 2, 2: 3, 3: 4})
-        
+        defaultdict(<type 'list'>, {0: 1, 1: 2, 2: 3, 3: 4})
         """
         # GH16122
-        into_c = prep_maping_for_to_dict(into)
+        into_c = standardize_mapping(into)
         return into_c(compat.iteritems(self))
 
     def to_frame(self, name=None):

pandas/tests/frame/test_convert_to.py

@@ -156,6 +156,7 @@ def test_to_dict(self, mapping):
             'A': {'1': 1, '2': 2},
             'B': {'1': '1', '2': '2', '3': '3'},
         }
+
         # GH16122
         recons_data = DataFrame(test_data).to_dict(into=mapping)
 
@@ -196,6 +197,15 @@ def test_to_dict(self, mapping):
             for k2, v2 in compat.iteritems(v):
                 assert (v2 == recons_data[k2][k])
 
+        df = DataFrame(test_data)
+        df['duped'] = df[df.columns[0]]
+        recons_data = df.to_dict("i")
+        comp_data = test_data.copy()
+        comp_data['duped'] = comp_data[df.columns[0]]
+        for k, v in compat.iteritems(comp_data):
+            for k2, v2 in compat.iteritems(v):
+                assert (v2 == recons_data[k2][k])
+
     @pytest.mark.parametrize('tz', ['UTC', 'GMT', 'US/Eastern'])
     def test_to_records_datetimeindex_with_tz(self, tz):
         # GH13937

pandas/tests/test_common.py

@@ -199,26 +199,24 @@ def test_dict_compat():
     assert (com._dict_compat(data_unchanged) == data_unchanged)
 
 
-def test_prep_maping_for_to_dict():
-    # No non-empty
-    bad = {'bad': 'data'}
-    with pytest.raises(ValueError):
-        com.prep_maping_for_to_dict(bad)
-
+def test_standardize_mapping():
     # No uninitialized defaultdicts
     with pytest.raises(TypeError):
-        com.prep_maping_for_to_dict(collections.defaultdict)
+        com.standardize_mapping(collections.defaultdict)
 
     # No non-mapping subtypes, instance
     with pytest.raises(TypeError):
-        com.prep_maping_for_to_dict([])
+        com.standardize_mapping([])
 
     # No non-mapping subtypes, class
     with pytest.raises(TypeError):
-        com.prep_maping_for_to_dict(list)
+        com.standardize_mapping(list)
+
+    fill = {'bad': 'data'}
+    assert (com.standardize_mapping(fill) == dict)
 
     # Convert instance to type
-    assert (com.prep_maping_for_to_dict({}) == dict)
+    assert (com.standardize_mapping({}) == dict)
 
     dd = collections.defaultdict(list)
-    assert (type(com.prep_maping_for_to_dict(dd)) == partial)
+    assert isinstance(com.standardize_mapping(dd), partial)