ENH: accept dict of column:dtype as dtype argument in DataFrame.astype

doc/source/whatsnew/v0.18.2.txt

@@ -30,8 +30,8 @@ Other enhancements
 ^^^^^^^^^^^^^^^^^^
 
 - The ``.tz_localize()`` method of ``DatetimeIndex`` and ``Timestamp`` has gained the ``errors`` keyword, so you can potentially coerce nonexistent timestamps to ``NaT``. The default behaviour remains to raising a ``NonExistentTimeError`` (:issue:`13057`)
-
-
+- The `copy` argument to the ``astype()`` functions has been deprecated in favor of a new ``inplace`` argument. (:issue:`12086`)
+- ``astype()`` will now accept a dict of column name to data types mapping as the ``dtype`` argument. (:issue:`12086`)
 
 
 .. _whatsnew_0182.api:

pandas/core/frame.py

@@ -3772,6 +3772,47 @@ def update(self, other, join='left', overwrite=True, filter_func=None,
     # ----------------------------------------------------------------------
     # Misc methods
 
+    def astype(self, dtype, copy=True, inplace=False, raise_on_error=True,
+               **kwargs):
+        """
+        Cast object to given data type(s).
+
+        Parameters
+        ----------
+        dtype : numpy.dtype or Python type (to cast entire DataFrame to the
+            same type). Alternatively, {col: dtype, ...}, where col is a column
+            label and dtype is a numpy.dtype or Python type (to cast one or
+            more of the DataFrame's columns to column-specific types).
+        copy : deprecated; use inplace instead
+        inplace : boolean, default False
+            Modify the DataFrame in place (do not create a new object)
+        raise_on_error : raise on invalid input
+        kwargs : keyword arguments to pass on to the constructor if
+            inplace=False
+
+        Returns
+        -------
+        casted : type of caller
+        """
+        if isinstance(dtype, collections.Mapping):
+            if inplace:
+                for col, typ in dtype.items():
+                    self[col].astype(typ, inplace=True,
+                                     raise_on_error=raise_on_error)
+                return None
+            else:
+                from pandas.tools.merge import concat
+                casted_cols = [self[col].astype(typ, copy=copy)
+                               for col, typ in dtype.items()]
+                other_col_labels = self.columns.difference(dtype.keys())
+                other_cols = [self[col].copy() if copy else self[col]
+                              for col in other_col_labels]
+                new_df = concat(casted_cols + other_cols, axis=1)
+                return new_df.reindex(columns=self.columns, copy=False)
+        df = super(DataFrame, self)
+        return df.astype(dtype=dtype, copy=copy, inplace=inplace,
+                         raise_on_error=raise_on_error, **kwargs)
+
     def first_valid_index(self):
         """
         Return label for first non-NA/null value

pandas/core/generic.py

@@ -143,7 +143,7 @@ def _init_mgr(self, mgr, axes=None, dtype=None, copy=False):
 
     @property
     def _constructor(self):
-        """Used when a manipulation result has the same dimesions as the
+        """Used when a manipulation result has the same dimensions as the
         original.
         """
         raise AbstractMethodError(self)
@@ -2930,22 +2930,30 @@ def blocks(self):
         """Internal property, property synonym for as_blocks()"""
         return self.as_blocks()
 
-    def astype(self, dtype, copy=True, raise_on_error=True, **kwargs):
+    def astype(self, dtype, copy=True, inplace=False, raise_on_error=True,
+               **kwargs):
         """
         Cast object to input numpy.dtype
-        Return a copy when copy = True (be really careful with this!)
 
         Parameters
         ----------
         dtype : numpy.dtype or Python type
+        copy : deprecated; use inplace instead
+        inplace : boolean, default False
+            Modify the NDFrame in place (do not create a new object)
         raise_on_error : raise on invalid input
         kwargs : keyword arguments to pass on to the constructor
 
         Returns
         -------
         casted : type of caller
         """
-
+        if inplace:
+            new_data = self._data.astype(dtype=dtype, copy=False,
+                                         raise_on_error=raise_on_error,
+                                         **kwargs)
+            self._update_inplace(new_data)
+            return
         mgr = self._data.astype(dtype=dtype, copy=copy,
                                 raise_on_error=raise_on_error, **kwargs)
         return self._constructor(mgr).__finalize__(self)

pandas/tests/frame/test_dtypes.py

@@ -372,6 +372,76 @@ def test_astype_str(self):
             expected = DataFrame(['1.12345678901'])
             assert_frame_equal(result, expected)
 
+    def test_astype_dict(self):
+        # GH7271
+        a = Series(date_range('2010-01-04', periods=5))
+        b = Series(range(5))
+        c = Series([0.0, 0.2, 0.4, 0.6, 0.8])
+        d = Series(['1.0', '2', '3.14', '4', '5.4'])
+        df = DataFrame({'a': a, 'b': b, 'c': c, 'd': d})
+        original = df.copy(deep=True)
+
+        # change type of a subset of columns
+        expected = DataFrame({
+            'a': a,
+            'b': Series(['0', '1', '2', '3', '4']),
+            'c': c,
+            'd': Series([1.0, 2.0, 3.14, 4.0, 5.4], dtype='float32')})
+        astyped = df.astype({'b': 'str', 'd': 'float32'})
+        assert_frame_equal(astyped, expected)
+        assert_frame_equal(df, original)
+        self.assertEqual(astyped.b.dtype, 'object')
+        self.assertEqual(astyped.d.dtype, 'float32')
+
+        # change all columns
+        assert_frame_equal(df.astype({'a': str, 'b': str, 'c': str, 'd': str}),
+                           df.astype(str))
+        assert_frame_equal(df, original)
+
+        # error should be raised when using something other than column labels
+        # in the keys of the dtype dict
+        self.assertRaises(KeyError, df.astype, {'b': str, 2: str})
+        self.assertRaises(KeyError, df.astype, {'e': str})
+        assert_frame_equal(df, original)
+
+        # if the dtypes provided are the same as the original dtypes, the
+        # resulting DataFrame should be the same as the original DataFrame
+        equiv = df.astype({col: df[col].dtype for col in df.columns})
+        assert_frame_equal(df, equiv)
+        assert_frame_equal(df, original)
+
+        # using inplace=True, the df should be changed
+        output = df.astype({'b': 'str', 'd': 'float32'}, inplace=True)
+        self.assertEqual(output, None)
+        assert_frame_equal(df, expected)
+        df.astype({'b': np.float32, 'c': 'float32', 'd': np.float32},
+                  inplace=True)
+        self.assertEqual(df.a.dtype, original.a.dtype)
+        self.assertEqual(df.b.dtype, 'float32')
+        self.assertEqual(df.c.dtype, 'float32')
+        self.assertEqual(df.d.dtype, 'float32')
+        self.assertEqual(df.b[0], 0.0)
+        df.astype({'b': str, 'c': 'float64', 'd': np.float64}, inplace=True)
+        self.assertEqual(df.a.dtype, original.a.dtype)
+        self.assertEqual(df.b.dtype, 'object')
+        self.assertEqual(df.c.dtype, 'float64')
+        self.assertEqual(df.d.dtype, 'float64')
+        self.assertEqual(df.b[0], '0.0')
+
+    def test_astype_inplace(self):
+        # GH7271
+        df = DataFrame({'a': range(10),
+                        'b': range(2, 12),
+                        'c': np.arange(4.0, 14.0, dtype='float64')})
+        df.astype('float', inplace=True)
+        for col in df.columns:
+            self.assertTrue(df[col].map(lambda x: type(x) == float).all())
+            self.assertEqual(df[col].dtype, 'float64')
+        df.astype('str', inplace=True)
+        for col in df.columns:
+            self.assertTrue(df[col].map(lambda x: type(x) == str).all())
+            self.assertEqual(df[col].dtype, 'object')
+
     def test_timedeltas(self):
         df = DataFrame(dict(A=Series(date_range('2012-1-1', periods=3,
                                                 freq='D')),

pandas/tests/series/test_dtypes.py

@@ -133,6 +133,19 @@ def test_astype_unicode(self):
             reload(sys)  # noqa
             sys.setdefaultencoding(former_encoding)
 
+    def test_astype_inplace(self):
+        s = Series(np.random.randn(5), name='foo')
+
+        for dtype in ['float32', 'float64', 'int64', 'int32']:
+            astyped = s.astype(dtype, inplace=False)
+            self.assertEqual(astyped.dtype, dtype)
+            self.assertEqual(astyped.name, s.name)
+
+        for dtype in ['float32', 'float64', 'int64', 'int32']:
+            s.astype(dtype, inplace=True)
+            self.assertEqual(s.dtype, dtype)
+            self.assertEqual(s.name, 'foo')
+
     def test_complexx(self):
         # GH4819
         # complex access for ndarray compat