FIX: Add boxing for to_numeric and add tests

Added support for unboxing/boxing to to_numeric
Added tests for to_numeric

Author: Sheppard, Kevin

doc/source/whatsnew/v0.17.0.txt

@@ -927,7 +927,7 @@ Deprecations
 - ``Series.is_time_series`` deprecated in favor of ``Series.index.is_all_dates`` (:issue:`11135`)
 - Legacy offsets (like ``'A@JAN'``) listed in :ref:`here <timeseries.legacyaliases>` are deprecated (note that this has been alias since 0.8.0), (:issue:`10878`)
 - ``WidePanel`` deprecated in favor of ``Panel``, ``LongPanel`` in favor of ``DataFrame`` (note these have been aliases since < 0.11.0), (:issue:`10892`)
-- ``DataFrame.convert_objects`` has been deprecated in favor of type-specific function ``pd.to_datetime``, ``pd.to_timestamp`` and ``pd.to_numeric``.
+- ``DataFrame.convert_objects`` has been deprecated in favor of type-specific function ``pd.to_datetime``, ``pd.to_timestamp`` and ``pd.to_numeric`` (:issue:`11133`).
 
 .. _whatsnew_0170.prior_deprecations:
 

pandas/core/convert.py

@@ -106,7 +106,7 @@ def _soft_convert_objects(values, datetime=True, numeric=True, timedelta=True,
         elif timedelta:
             return pd.to_timedelta(values, errors='coerce', box=False)
         elif numeric:
-            return lib.maybe_convert_numeric(values, set(), coerce_numeric=True)
+            return pd.to_numeric(values, errors='coerce')
 
     # Soft conversions
     if datetime:

pandas/tests/test_series.py

@@ -6452,35 +6452,41 @@ def test_apply_dont_convert_dtype(self):
     def test_convert_objects(self):
 
         s = Series([1., 2, 3], index=['a', 'b', 'c'])
-        result = s.convert_objects(convert_dates=False, convert_numeric=True)
+        with tm.assert_produces_warning(FutureWarning):
+            result = s.convert_objects(convert_dates=False, convert_numeric=True)
         assert_series_equal(result, s)
 
         # force numeric conversion
         r = s.copy().astype('O')
         r['a'] = '1'
-        result = r.convert_objects(convert_dates=False, convert_numeric=True)
+        with tm.assert_produces_warning(FutureWarning):
+            result = r.convert_objects(convert_dates=False, convert_numeric=True)
         assert_series_equal(result, s)
 
         r = s.copy().astype('O')
         r['a'] = '1.'
-        result = r.convert_objects(convert_dates=False, convert_numeric=True)
+        with tm.assert_produces_warning(FutureWarning):
+            result = r.convert_objects(convert_dates=False, convert_numeric=True)
         assert_series_equal(result, s)
 
         r = s.copy().astype('O')
         r['a'] = 'garbled'
         expected = s.copy()
         expected['a'] = np.nan
-        result = r.convert_objects(convert_dates=False, convert_numeric=True)
+        with tm.assert_produces_warning(FutureWarning):
+            result = r.convert_objects(convert_dates=False, convert_numeric=True)
         assert_series_equal(result, expected)
 
         # GH 4119, not converting a mixed type (e.g.floats and object)
         s = Series([1, 'na', 3, 4])
-        result = s.convert_objects(convert_numeric=True)
+        with tm.assert_produces_warning(FutureWarning):
+            result = s.convert_objects(convert_numeric=True)
         expected = Series([1, np.nan, 3, 4])
         assert_series_equal(result, expected)
 
         s = Series([1, '', 3, 4])
-        result = s.convert_objects(convert_numeric=True)
+        with tm.assert_produces_warning(FutureWarning):
+            result = s.convert_objects(convert_numeric=True)
         expected = Series([1, np.nan, 3, 4])
         assert_series_equal(result, expected)
 
@@ -6489,39 +6495,45 @@ def test_convert_objects(self):
             [datetime(2001, 1, 1, 0, 0), datetime(2001, 1, 2, 0, 0), datetime(2001, 1, 3, 0, 0)])
         s2 = Series([datetime(2001, 1, 1, 0, 0), datetime(2001, 1, 2, 0, 0), datetime(
             2001, 1, 3, 0, 0), 'foo', 1.0, 1, Timestamp('20010104'), '20010105'], dtype='O')
-
-        result = s.convert_objects(convert_dates=True, convert_numeric=False)
+        with tm.assert_produces_warning(FutureWarning):
+            result = s.convert_objects(convert_dates=True, convert_numeric=False)
         expected = Series(
             [Timestamp('20010101'), Timestamp('20010102'), Timestamp('20010103')], dtype='M8[ns]')
         assert_series_equal(result, expected)
 
-        result = s.convert_objects(
-            convert_dates='coerce', convert_numeric=False)
-        result = s.convert_objects(
-            convert_dates='coerce', convert_numeric=True)
+        with tm.assert_produces_warning(FutureWarning):
+            result = s.convert_objects(convert_dates='coerce',
+                                       convert_numeric=False)
+        with tm.assert_produces_warning(FutureWarning):
+            result = s.convert_objects(convert_dates='coerce',
+                                       convert_numeric=True)
         assert_series_equal(result, expected)
 
         expected = Series(
             [Timestamp(
                 '20010101'), Timestamp('20010102'), Timestamp('20010103'),
                           lib.NaT, lib.NaT, lib.NaT, Timestamp('20010104'), Timestamp('20010105')], dtype='M8[ns]')
-        result = s2.convert_objects(
-            convert_dates='coerce', convert_numeric=False)
+        with tm.assert_produces_warning(FutureWarning):
+            result = s2.convert_objects(convert_dates='coerce',
+                                        convert_numeric=False)
         assert_series_equal(result, expected)
-        result = s2.convert_objects(
-            convert_dates='coerce', convert_numeric=True)
+        with tm.assert_produces_warning(FutureWarning):
+            result = s2.convert_objects(convert_dates='coerce',
+                                        convert_numeric=True)
         assert_series_equal(result, expected)
 
         # preserver all-nans (if convert_dates='coerce')
         s = Series(['foo', 'bar', 1, 1.0], dtype='O')
-        result = s.convert_objects(
-            convert_dates='coerce', convert_numeric=False)
+        with tm.assert_produces_warning(FutureWarning):
+            result = s.convert_objects(convert_dates='coerce',
+                                       convert_numeric=False)
         assert_series_equal(result, s)
 
         # preserver if non-object
         s = Series([1], dtype='float32')
-        result = s.convert_objects(
-            convert_dates='coerce', convert_numeric=False)
+        with tm.assert_produces_warning(FutureWarning):
+            result = s.convert_objects(convert_dates='coerce',
+                                       convert_numeric=False)
         assert_series_equal(result, s)
 
         #r = s.copy()
@@ -6532,21 +6544,25 @@ def test_convert_objects(self):
         # dateutil parses some single letters into today's value as a date
         for x in 'abcdefghijklmnopqrstuvwxyz':
             s = Series([x])
-            result = s.convert_objects(convert_dates='coerce')
+            with tm.assert_produces_warning(FutureWarning):
+                result = s.convert_objects(convert_dates='coerce')
             assert_series_equal(result, s)
             s = Series([x.upper()])
-            result = s.convert_objects(convert_dates='coerce')
+            with tm.assert_produces_warning(FutureWarning):
+                result = s.convert_objects(convert_dates='coerce')
             assert_series_equal(result, s)
 
     def test_convert_objects_preserve_bool(self):
         s = Series([1, True, 3, 5], dtype=object)
-        r = s.convert_objects(convert_numeric=True)
+        with tm.assert_produces_warning(FutureWarning):
+            r = s.convert_objects(convert_numeric=True)
         e = Series([1, 1, 3, 5], dtype='i8')
         tm.assert_series_equal(r, e)
 
     def test_convert_objects_preserve_all_bool(self):
         s = Series([False, True, False, False], dtype=object)
-        r = s.convert_objects(convert_numeric=True)
+        with tm.assert_produces_warning(FutureWarning):
+            r = s.convert_objects(convert_numeric=True)
         e = Series([False, True, False, False], dtype=bool)
         tm.assert_series_equal(r, e)
 

pandas/tests/test_util.py

@@ -1,13 +1,11 @@
 # -*- coding: utf-8 -*-
-import warnings
-
 import nose
 
-import sys
-import pandas.util
 from pandas.util.decorators import deprecate_kwarg
 import pandas.util.testing as tm
 
+
+
 class TestDecorators(tm.TestCase):
     def setUp(self):
         @deprecate_kwarg('old', 'new')
@@ -75,7 +73,6 @@ def test_rands_array():
     assert(arr.shape == (10, 10))
     assert(len(arr[1, 1]) == 7)
 
-
 if __name__ == '__main__':
     nose.runmodule(argv=[__file__, '-vvs', '-x', '--pdb', '--pdb-failure'],
                    exit=False)

pandas/tools/tests/test_util.py

@@ -2,14 +2,15 @@
 import locale
 import codecs
 import nose
+from nose.tools import assert_raises, assert_true
 
 import numpy as np
 from numpy.testing import assert_equal
 
+import pandas as pd
 from pandas import date_range, Index
 import pandas.util.testing as tm
-from pandas.tools.util import cartesian_product
-
+from pandas.tools.util import cartesian_product, to_numeric
 
 CURRENT_LOCALE = locale.getlocale()
 LOCALE_OVERRIDE = os.environ.get('LOCALE_OVERRIDE', None)
@@ -89,6 +90,54 @@ def test_set_locale(self):
         self.assertEqual(current_locale, CURRENT_LOCALE)
 
 
+class TestToNumeric(tm.TestCase):
+    def test_series(self):
+        s = pd.Series(['1', '-3.14', '7'])
+        res = to_numeric(s)
+        expected = pd.Series([1, -3.14, 7])
+        tm.assert_series_equal(res, expected)
+
+        s = pd.Series(['1', '-3.14', 7])
+        res = to_numeric(s)
+        tm.assert_series_equal(res, expected)
+
+    def test_error(self):
+        s = pd.Series([1, -3.14, 'apple'])
+        assert_raises(ValueError, to_numeric, s, errors='raise')
+
+        res = to_numeric(s, errors='ignore')
+        expected = pd.Series([1, -3.14, 'apple'])
+        tm.assert_series_equal(res, expected)
+
+        res = to_numeric(s, errors='coerce')
+        expected = pd.Series([1, -3.14, np.nan])
+        tm.assert_series_equal(res, expected)
+
+
+    def test_list(self):
+        s = ['1', '-3.14', '7']
+        res = to_numeric(s)
+        expected = np.array([1, -3.14, 7])
+        tm.assert_numpy_array_equal(res, expected)
+
+    def test_numeric(self):
+        s = pd.Series([1, -3.14, 7], dtype='O')
+        res = to_numeric(s)
+        expected = pd.Series([1, -3.14, 7])
+        tm.assert_series_equal(res, expected)
+
+        s = pd.Series([1, -3.14, 7])
+        res = to_numeric(s)
+        tm.assert_series_equal(res, expected)
+
+    def test_all_nan(self):
+        s = pd.Series(['a','b','c'])
+        res = to_numeric(s, errors='coerce')
+        expected = pd.Series([np.nan, np.nan, np.nan])
+        tm.assert_series_equal(res, expected)
+
+
 if __name__ == '__main__':
     nose.runmodule(argv=[__file__, '-vvs', '-x', '--pdb', '--pdb-failure'],
                    exit=False)
+

pandas/tools/util.py

@@ -1,9 +1,9 @@
-import operator
-import warnings
+import numpy as np
+import pandas.lib as lib
+
+import pandas as pd
 from pandas.compat import reduce
 from pandas.core.index import Index
-import numpy as np
-from pandas import algos
 from pandas.core import common as com
 
 
@@ -50,47 +50,55 @@ def compose(*funcs):
     return reduce(_compose2, funcs)
 
 
-def to_numeric(arg, errors='raise', box=True, coerce=None):
+def to_numeric(arg, errors='raise'):
     """
     Convert argument to a numeric type.
 
     Parameters
     ----------
-    arg : string, datetime, array of strings (with possible NAs)
+    arg : list, tuple or array of objects, or Series
     errors : {'ignore', 'raise', 'coerce'}, default 'raise'
         - If 'raise', then invalid parsing will raise an exception
-        - If 'coerce', then invalid parsing will be set as NaT
+        - If 'coerce', then invalid parsing will be set as NaN
         - If 'ignore', then invalid parsing will return the input
-    box : boolean, default True
-        - If True returns a Series
-        - If False returns ndarray of values.
 
     Returns
     -------
     ret : numeric if parsing succeeded.
-        Return type depends on box
-
+        Return type depends on input.  Series if Series, otherwise ndarray
 
     Examples
     --------
-    Take separate series and convert to datetime
+    Take separate series and convert to numeric, coercing when told to
 
     >>> import pandas as pd
-    >>> df = pd.DataFrame(['1.0', '2', -3])
-    >>> pd.to_numeric(df)
-    >>> df = pd.DataFrame(['apple', '1.0', '2', -3])
-    >>> pd.to_numeric(df, errors='ignore')
-    >>> pd.to_numeric(df, errors='coerce')
+    >>> s = pd.Series(['1.0', '2', -3])
+    >>> pd.to_numeric(s)
+    >>> s = pd.Series(['apple', '1.0', '2', -3])
+    >>> pd.to_numeric(s, errors='ignore')
+    >>> pd.to_numeric(s, errors='coerce')
     """
-    #TODO: Fix examples
+
+    index = name = None
+    if isinstance(arg, pd.Series):
+        index, name = arg.index, arg.name
+    elif isinstance(arg, (list, tuple)):
+        arg = np.array(arg, dtype='O')
+
+    conv = arg
+    arg = com._ensure_object(arg)
 
     coerce_numeric = False if errors in ('ignore', 'raise') else True
-    if errors == 'ignore':
-        try:
-            values = lib.maybe_convert_numeric(arg,
-                                               set(),
-                                               coerce_numeric=coerce_numeric)
-            return values
-        except:
-            return arg
-    return lib.maybe_convert_numeric(arg, set(), coerce_numeric=coerce_numeric)
+
+    try:
+        conv = lib.maybe_convert_numeric(arg,
+                                         set(),
+                                         coerce_numeric=coerce_numeric)
+    except:
+        if errors == 'raise':
+            raise
+
+    if index is not None:
+        return pd.Series(conv, index=index, name=name)
+    else:
+        return conv