From e7762acab496c061adfcc3f609bc5528ad3de2c3 Mon Sep 17 00:00:00 2001 From: Anjali Singhal Date: Wed, 19 Sep 2018 00:42:48 +0200 Subject: [PATCH 1/8] TST: Fixturize series/test_analytics.py --- pandas/tests/series/test_analytics.py | 218 +++++++++++++------------- 1 file changed, 108 insertions(+), 110 deletions(-) diff --git a/pandas/tests/series/test_analytics.py b/pandas/tests/series/test_analytics.py index d5d9e5f4f14de..62f6593f567a8 100644 --- a/pandas/tests/series/test_analytics.py +++ b/pandas/tests/series/test_analytics.py @@ -24,10 +24,8 @@ assert_frame_equal, assert_index_equal) import pandas.util.testing as tm import pandas.util._test_decorators as td -from .common import TestData - -class TestSeriesAnalytics(TestData): +class TestSeriesAnalytics(): @pytest.mark.parametrize("use_bottleneck", [True, False]) @pytest.mark.parametrize("method, unit", [ @@ -194,8 +192,8 @@ def test_sum_overflow(self, use_bottleneck): result = s.max(skipna=False) assert np.allclose(float(result), v[-1]) - def test_sum(self): - self._check_stat_op('sum', np.sum, check_allna=False) + def test_sum(self, string_series): + self._check_stat_op('sum', np.sum, string_series, check_allna=False) def test_sum_inf(self): s = Series(np.random.randn(10)) @@ -215,67 +213,67 @@ def test_sum_inf(self): res = nanops.nansum(arr, axis=1) assert np.isinf(res).all() - def test_mean(self): - self._check_stat_op('mean', np.mean) + def test_mean(self, string_series): + self._check_stat_op('mean', np.mean, string_series) - def test_median(self): - self._check_stat_op('median', np.median) + def test_median(self, string_series): + self._check_stat_op('median', np.median, string_series) # test with integers, test failure int_ts = Series(np.ones(10, dtype=int), index=lrange(10)) tm.assert_almost_equal(np.median(int_ts), int_ts.median()) - def test_prod(self): - self._check_stat_op('prod', np.prod) + def test_prod(self, string_series): + self._check_stat_op('prod', np.prod, string_series) - def test_min(self): - self._check_stat_op('min', np.min, check_objects=True) + def test_min(self, string_series): + self._check_stat_op('min', np.min, string_series, check_objects=True) - def test_max(self): - self._check_stat_op('max', np.max, check_objects=True) + def test_max(self, string_series): + self._check_stat_op('max', np.max, string_series, check_objects=True) - def test_var_std(self): + def test_var_std(self, datetime_series, string_series): alt = lambda x: np.std(x, ddof=1) - self._check_stat_op('std', alt) + self._check_stat_op('std', alt, string_series) alt = lambda x: np.var(x, ddof=1) - self._check_stat_op('var', alt) + self._check_stat_op('var', alt, string_series) - result = self.ts.std(ddof=4) - expected = np.std(self.ts.values, ddof=4) + result = datetime_series.std(ddof=4) + expected = np.std(datetime_series.values, ddof=4) assert_almost_equal(result, expected) - result = self.ts.var(ddof=4) - expected = np.var(self.ts.values, ddof=4) + result = datetime_series.var(ddof=4) + expected = np.var(datetime_series.values, ddof=4) assert_almost_equal(result, expected) # 1 - element series with ddof=1 - s = self.ts.iloc[[0]] + s = datetime_series.iloc[[0]] result = s.var(ddof=1) assert isna(result) result = s.std(ddof=1) assert isna(result) - def test_sem(self): + def test_sem(self, datetime_series, string_series): alt = lambda x: np.std(x, ddof=1) / np.sqrt(len(x)) - self._check_stat_op('sem', alt) + self._check_stat_op('sem', alt, string_series) - result = self.ts.sem(ddof=4) - expected = np.std(self.ts.values, - ddof=4) / np.sqrt(len(self.ts.values)) + result = datetime_series.sem(ddof=4) + expected = np.std(datetime_series.values, + ddof=4) / np.sqrt(len(datetime_series.values)) assert_almost_equal(result, expected) # 1 - element series with ddof=1 - s = self.ts.iloc[[0]] + s = datetime_series.iloc[[0]] result = s.sem(ddof=1) assert isna(result) @td.skip_if_no_scipy - def test_skew(self): + def test_skew(self, string_series): from scipy.stats import skew alt = lambda x: skew(x, bias=False) - self._check_stat_op('skew', alt) + self._check_stat_op('skew', alt, string_series) # test corner cases, skew() returns NaN unless there's at least 3 # values @@ -291,10 +289,10 @@ def test_skew(self): assert (df.skew() == 0).all() @td.skip_if_no_scipy - def test_kurt(self): + def test_kurt(self, string_series): from scipy.stats import kurtosis alt = lambda x: kurtosis(x, bias=False) - self._check_stat_op('kurt', alt) + self._check_stat_op('kurt', alt, string_series) index = MultiIndex(levels=[['bar'], ['one', 'two', 'three'], [0, 1]], labels=[[0, 0, 0, 0, 0, 0], [0, 1, 2, 0, 1, 2], @@ -353,9 +351,9 @@ def test_describe_with_tz(self, tz_naive_fixture): ) tm.assert_series_equal(result, expected) - def test_argsort(self): - self._check_accum_op('argsort', check_dtype=False) - argsorted = self.ts.argsort() + def test_argsort(self, datetime_series): + self._check_accum_op('argsort', datetime_series, check_dtype=False) + argsorted = datetime_series.argsort() assert issubclass(argsorted.dtype.type, np.integer) # GH 2967 (introduced bug in 0.11-dev I think) @@ -388,26 +386,26 @@ def test_argsort_stable(self): pytest.raises(AssertionError, tm.assert_numpy_array_equal, qindexer, mindexer) - def test_cumsum(self): - self._check_accum_op('cumsum') + def test_cumsum(self, datetime_series): + self._check_accum_op('cumsum', datetime_series) - def test_cumprod(self): - self._check_accum_op('cumprod') + def test_cumprod(self, datetime_series): + self._check_accum_op('cumprod', datetime_series) - def test_cummin(self): - tm.assert_numpy_array_equal(self.ts.cummin().values, - np.minimum.accumulate(np.array(self.ts))) - ts = self.ts.copy() + def test_cummin(self, datetime_series): + tm.assert_numpy_array_equal(datetime_series.cummin().values, + np.minimum.accumulate(np.array(datetime_series))) + ts = datetime_series.copy() ts[::2] = np.NaN result = ts.cummin()[1::2] expected = np.minimum.accumulate(ts.dropna()) tm.assert_series_equal(result, expected) - def test_cummax(self): - tm.assert_numpy_array_equal(self.ts.cummax().values, - np.maximum.accumulate(np.array(self.ts))) - ts = self.ts.copy() + def test_cummax(self, datetime_series): + tm.assert_numpy_array_equal(datetime_series.cummax().values, + np.maximum.accumulate(np.array(datetime_series))) + ts = datetime_series.copy() ts[::2] = np.NaN result = ts.cummax()[1::2] expected = np.maximum.accumulate(ts.dropna()) @@ -506,14 +504,14 @@ def test_npdiff(self): r = np.diff(s) assert_series_equal(Series([nan, 0, 0, 0, nan]), r) - def _check_stat_op(self, name, alternate, check_objects=False, + def _check_stat_op(self, name, alternate, string_series_, check_objects=False, check_allna=False): with pd.option_context('use_bottleneck', False): f = getattr(Series, name) # add some NaNs - self.series[5:15] = np.NaN + string_series_[5:15] = np.NaN # idxmax, idxmin, min, and max are valid for dates if name not in ['max', 'min']: @@ -521,15 +519,15 @@ def _check_stat_op(self, name, alternate, check_objects=False, pytest.raises(TypeError, f, ds) # skipna or no - assert notna(f(self.series)) - assert isna(f(self.series, skipna=False)) + assert notna(f(string_series_)) + assert isna(f(string_series_, skipna=False)) # check the result is correct - nona = self.series.dropna() + nona = string_series_.dropna() assert_almost_equal(f(nona), alternate(nona.values)) - assert_almost_equal(f(self.series), alternate(nona.values)) + assert_almost_equal(f(string_series_), alternate(nona.values)) - allna = self.series * nan + allna = string_series_ * nan if check_allna: assert np.isnan(f(allna)) @@ -556,21 +554,21 @@ def _check_stat_op(self, name, alternate, check_objects=False, pytest.raises(TypeError, f, Series(list('abc'))) # Invalid axis. - pytest.raises(ValueError, f, self.series, axis=1) + pytest.raises(ValueError, f, string_series_, axis=1) # Unimplemented numeric_only parameter. if 'numeric_only' in compat.signature(f).args: tm.assert_raises_regex(NotImplementedError, name, f, - self.series, numeric_only=True) + string_series_, numeric_only=True) - def _check_accum_op(self, name, check_dtype=True): + def _check_accum_op(self, name, datetime_series_, check_dtype=True): func = getattr(np, name) - tm.assert_numpy_array_equal(func(self.ts).values, - func(np.array(self.ts)), + tm.assert_numpy_array_equal(func(datetime_series_).values, + func(np.array(datetime_series_)), check_dtype=check_dtype) # with missing values - ts = self.ts.copy() + ts = datetime_series_.copy() ts[::2] = np.NaN result = func(ts)[1::2] @@ -607,13 +605,13 @@ def test_numpy_compress(self): tm.assert_raises_regex(ValueError, msg, np.compress, cond, s, out=s) - def test_round(self): - self.ts.index.name = "index_name" - result = self.ts.round(2) - expected = Series(np.round(self.ts.values, 2), - index=self.ts.index, name='ts') + def test_round(self, datetime_series): + datetime_series.index.name = "index_name" + result = datetime_series.round(2) + expected = Series(np.round(datetime_series.values, 2), + index=datetime_series.index, name='ts') assert_series_equal(result, expected) - assert result.name == self.ts.name + assert result.name == datetime_series.name def test_numpy_round(self): # See gh-12600 @@ -717,26 +715,26 @@ def test_modulo(self): assert_series_equal(result, expected) @td.skip_if_no_scipy - def test_corr(self): + def test_corr(self, datetime_series): import scipy.stats as stats # full overlap - tm.assert_almost_equal(self.ts.corr(self.ts), 1) + tm.assert_almost_equal(datetime_series.corr(datetime_series), 1) # partial overlap - tm.assert_almost_equal(self.ts[:15].corr(self.ts[5:]), 1) + tm.assert_almost_equal(datetime_series[:15].corr(datetime_series[5:]), 1) - assert isna(self.ts[:15].corr(self.ts[5:], min_periods=12)) + assert isna(datetime_series[:15].corr(datetime_series[5:], min_periods=12)) - ts1 = self.ts[:15].reindex(self.ts.index) - ts2 = self.ts[5:].reindex(self.ts.index) + ts1 = datetime_series[:15].reindex(datetime_series.index) + ts2 = datetime_series[5:].reindex(datetime_series.index) assert isna(ts1.corr(ts2, min_periods=12)) # No overlap - assert np.isnan(self.ts[::2].corr(self.ts[1::2])) + assert np.isnan(datetime_series[::2].corr(datetime_series[1::2])) # all NA - cp = self.ts[:10].copy() + cp = datetime_series[:10].copy() cp[:] = np.nan assert isna(cp.corr(cp)) @@ -789,35 +787,35 @@ def test_corr_invalid_method(self): with tm.assert_raises_regex(ValueError, msg): s1.corr(s2, method="____") - def test_cov(self): + def test_cov(self, datetime_series): # full overlap - tm.assert_almost_equal(self.ts.cov(self.ts), self.ts.std() ** 2) + tm.assert_almost_equal(datetime_series.cov(datetime_series), datetime_series.std() ** 2) # partial overlap - tm.assert_almost_equal(self.ts[:15].cov(self.ts[5:]), - self.ts[5:15].std() ** 2) + tm.assert_almost_equal(datetime_series[:15].cov(datetime_series[5:]), + datetime_series[5:15].std() ** 2) # No overlap - assert np.isnan(self.ts[::2].cov(self.ts[1::2])) + assert np.isnan(datetime_series[::2].cov(datetime_series[1::2])) # all NA - cp = self.ts[:10].copy() + cp = datetime_series[:10].copy() cp[:] = np.nan assert isna(cp.cov(cp)) # min_periods - assert isna(self.ts[:15].cov(self.ts[5:], min_periods=12)) + assert isna(datetime_series[:15].cov(datetime_series[5:], min_periods=12)) - ts1 = self.ts[:15].reindex(self.ts.index) - ts2 = self.ts[5:].reindex(self.ts.index) + ts1 = datetime_series[:15].reindex(datetime_series.index) + ts2 = datetime_series[5:].reindex(datetime_series.index) assert isna(ts1.cov(ts2, min_periods=12)) - def test_count(self): - assert self.ts.count() == len(self.ts) + def test_count(self, datetime_series): + assert datetime_series.count() == len(datetime_series) - self.ts[::2] = np.NaN + datetime_series[::2] = np.NaN - assert self.ts.count() == np.isfinite(self.ts).sum() + assert datetime_series.count() == np.isfinite(datetime_series).sum() mi = MultiIndex.from_arrays([list('aabbcc'), [1, 2, 2, nan, 1, 2]]) ts = Series(np.arange(len(mi)), index=mi) @@ -920,17 +918,17 @@ def test_matmul(self): pytest.raises(Exception, a.dot, a.values[:3]) pytest.raises(ValueError, a.dot, b.T) - def test_clip(self): - val = self.ts.median() + def test_clip(self, datetime_series): + val = datetime_series.median() - assert self.ts.clip_lower(val).min() == val - assert self.ts.clip_upper(val).max() == val + assert datetime_series.clip_lower(val).min() == val + assert datetime_series.clip_upper(val).max() == val - assert self.ts.clip(lower=val).min() == val - assert self.ts.clip(upper=val).max() == val + assert datetime_series.clip(lower=val).min() == val + assert datetime_series.clip(upper=val).max() == val - result = self.ts.clip(-0.5, 0.5) - expected = np.clip(self.ts, -0.5, 0.5) + result = datetime_series.clip(-0.5, 0.5) + expected = np.clip(datetime_series, -0.5, 0.5) assert_series_equal(result, expected) assert isinstance(expected, Series) @@ -1164,25 +1162,25 @@ def test_timedelta64_analytics(self): expected = Timedelta('1 days') assert result == expected - def test_idxmin(self): + def test_idxmin(self, string_series): # test idxmin # _check_stat_op approach can not be used here because of isna check. # add some NaNs - self.series[5:15] = np.NaN + string_series[5:15] = np.NaN # skipna or no - assert self.series[self.series.idxmin()] == self.series.min() - assert isna(self.series.idxmin(skipna=False)) + assert string_series[string_series.idxmin()] == string_series.min() + assert isna(string_series.idxmin(skipna=False)) # no NaNs - nona = self.series.dropna() + nona = string_series.dropna() assert nona[nona.idxmin()] == nona.min() assert (nona.index.values.tolist().index(nona.idxmin()) == nona.values.argmin()) # all NaNs - allna = self.series * nan + allna = string_series * nan assert isna(allna.idxmin()) # datetime64[ns] @@ -1221,25 +1219,25 @@ def test_numpy_argmin_deprecated(self): tm.assert_raises_regex(ValueError, msg, np.argmin, s, out=data) - def test_idxmax(self): + def test_idxmax(self, string_series): # test idxmax # _check_stat_op approach can not be used here because of isna check. # add some NaNs - self.series[5:15] = np.NaN + string_series[5:15] = np.NaN # skipna or no - assert self.series[self.series.idxmax()] == self.series.max() - assert isna(self.series.idxmax(skipna=False)) + assert string_series[string_series.idxmax()] == string_series.max() + assert isna(string_series.idxmax(skipna=False)) # no NaNs - nona = self.series.dropna() + nona = string_series.dropna() assert nona[nona.idxmax()] == nona.max() assert (nona.index.values.tolist().index(nona.idxmax()) == nona.values.argmax()) # all NaNs - allna = self.series * nan + allna = string_series * nan assert isna(allna.idxmax()) from pandas import date_range @@ -1458,8 +1456,8 @@ def test_apply_categorical(self): tm.assert_series_equal(result, exp) assert result.dtype == np.object - def test_shift_int(self): - ts = self.ts.astype(int) + def test_shift_int(self, datetime_series): + ts = datetime_series.astype(int) shifted = ts.shift(1) expected = ts.astype(float).shift(1) assert_series_equal(shifted, expected) From 368b7562a2a280a2388a352c8d918aba81170443 Mon Sep 17 00:00:00 2001 From: Anjali Singhal Date: Wed, 19 Sep 2018 00:56:32 +0200 Subject: [PATCH 2/8] Fixing PEP8 issues --- pandas/tests/series/test_analytics.py | 23 +++++++++++++++-------- 1 file changed, 15 insertions(+), 8 deletions(-) diff --git a/pandas/tests/series/test_analytics.py b/pandas/tests/series/test_analytics.py index 62f6593f567a8..9dbe0a719f484 100644 --- a/pandas/tests/series/test_analytics.py +++ b/pandas/tests/series/test_analytics.py @@ -25,6 +25,7 @@ import pandas.util.testing as tm import pandas.util._test_decorators as td + class TestSeriesAnalytics(): @pytest.mark.parametrize("use_bottleneck", [True, False]) @@ -394,7 +395,8 @@ def test_cumprod(self, datetime_series): def test_cummin(self, datetime_series): tm.assert_numpy_array_equal(datetime_series.cummin().values, - np.minimum.accumulate(np.array(datetime_series))) + np.minimum.accumulate( + np.array(datetime_series))) ts = datetime_series.copy() ts[::2] = np.NaN result = ts.cummin()[1::2] @@ -404,7 +406,8 @@ def test_cummin(self, datetime_series): def test_cummax(self, datetime_series): tm.assert_numpy_array_equal(datetime_series.cummax().values, - np.maximum.accumulate(np.array(datetime_series))) + np.maximum.accumulate( + np.array(datetime_series))) ts = datetime_series.copy() ts[::2] = np.NaN result = ts.cummax()[1::2] @@ -504,8 +507,8 @@ def test_npdiff(self): r = np.diff(s) assert_series_equal(Series([nan, 0, 0, 0, nan]), r) - def _check_stat_op(self, name, alternate, string_series_, check_objects=False, - check_allna=False): + def _check_stat_op(self, name, alternate, string_series_, + check_objects=False, check_allna=False): with pd.option_context('use_bottleneck', False): f = getattr(Series, name) @@ -722,9 +725,11 @@ def test_corr(self, datetime_series): tm.assert_almost_equal(datetime_series.corr(datetime_series), 1) # partial overlap - tm.assert_almost_equal(datetime_series[:15].corr(datetime_series[5:]), 1) + tm.assert_almost_equal(datetime_series[:15].corr(datetime_series[5:]), + 1) - assert isna(datetime_series[:15].corr(datetime_series[5:], min_periods=12)) + assert isna(datetime_series[:15].corr(datetime_series[5:], + min_periods=12)) ts1 = datetime_series[:15].reindex(datetime_series.index) ts2 = datetime_series[5:].reindex(datetime_series.index) @@ -789,7 +794,8 @@ def test_corr_invalid_method(self): def test_cov(self, datetime_series): # full overlap - tm.assert_almost_equal(datetime_series.cov(datetime_series), datetime_series.std() ** 2) + tm.assert_almost_equal(datetime_series.cov(datetime_series), + datetime_series.std() ** 2) # partial overlap tm.assert_almost_equal(datetime_series[:15].cov(datetime_series[5:]), @@ -804,7 +810,8 @@ def test_cov(self, datetime_series): assert isna(cp.cov(cp)) # min_periods - assert isna(datetime_series[:15].cov(datetime_series[5:], min_periods=12)) + assert isna(datetime_series[:15].cov(datetime_series[5:], + min_periods=12)) ts1 = datetime_series[:15].reindex(datetime_series.index) ts2 = datetime_series[5:].reindex(datetime_series.index) From 3678a62e75bc6b83265195450f4f1283c732c605 Mon Sep 17 00:00:00 2001 From: Anjali Singhal Date: Wed, 19 Sep 2018 01:23:38 +0200 Subject: [PATCH 3/8] Fixing PEP8 issues --- pandas/tests/series/test_analytics.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/pandas/tests/series/test_analytics.py b/pandas/tests/series/test_analytics.py index 9dbe0a719f484..3fec2c6a3baba 100644 --- a/pandas/tests/series/test_analytics.py +++ b/pandas/tests/series/test_analytics.py @@ -395,8 +395,8 @@ def test_cumprod(self, datetime_series): def test_cummin(self, datetime_series): tm.assert_numpy_array_equal(datetime_series.cummin().values, - np.minimum.accumulate( - np.array(datetime_series))) + np.minimum + .accumulate(np.array(datetime_series))) ts = datetime_series.copy() ts[::2] = np.NaN result = ts.cummin()[1::2] @@ -406,8 +406,8 @@ def test_cummin(self, datetime_series): def test_cummax(self, datetime_series): tm.assert_numpy_array_equal(datetime_series.cummax().values, - np.maximum.accumulate( - np.array(datetime_series))) + np.maximum + .accumulate(np.array(datetime_series))) ts = datetime_series.copy() ts[::2] = np.NaN result = ts.cummax()[1::2] From 795cdc1d5d5cbcc351a4e5aa61d3810d2cb48172 Mon Sep 17 00:00:00 2001 From: Anjali Singhal Date: Wed, 19 Sep 2018 01:32:39 +0200 Subject: [PATCH 4/8] TST: Fixturize series/test_validate.py --- pandas/tests/series/test_validate.py | 11 ++--------- 1 file changed, 2 insertions(+), 9 deletions(-) diff --git a/pandas/tests/series/test_validate.py b/pandas/tests/series/test_validate.py index a0cde5f81d021..8c4b6ee5b1d75 100644 --- a/pandas/tests/series/test_validate.py +++ b/pandas/tests/series/test_validate.py @@ -1,14 +1,7 @@ -from pandas.core.series import Series - import pytest import pandas.util.testing as tm -@pytest.fixture -def series(): - return Series([1, 2, 3, 4, 5]) - - class TestSeriesValidate(object): """Tests for error handling related to data types of method arguments.""" @@ -16,7 +9,7 @@ class TestSeriesValidate(object): "sort_values", "sort_index", "rename", "dropna"]) @pytest.mark.parametrize("inplace", [1, "True", [1, 2, 3], 5.0]) - def test_validate_bool_args(self, series, func, inplace): + def test_validate_bool_args(self, string_series, func, inplace): msg = "For argument \"inplace\" expected type bool" kwargs = dict(inplace=inplace) @@ -24,4 +17,4 @@ def test_validate_bool_args(self, series, func, inplace): kwargs["name"] = "hello" with tm.assert_raises_regex(ValueError, msg): - getattr(series, func)(**kwargs) + getattr(string_series, func)(**kwargs) From 52ebfa0b416df2f1934eb902c98f522ecc899d6b Mon Sep 17 00:00:00 2001 From: Anjali Singhal Date: Wed, 19 Sep 2018 19:36:35 +0200 Subject: [PATCH 5/8] TST: Fixturize series/test_api.py --- pandas/tests/series/test_api.py | 168 ++++++++++++++++---------------- 1 file changed, 83 insertions(+), 85 deletions(-) diff --git a/pandas/tests/series/test_api.py b/pandas/tests/series/test_api.py index da9b03e81994d..b6f32f2efa46c 100644 --- a/pandas/tests/series/test_api.py +++ b/pandas/tests/series/test_api.py @@ -19,8 +19,6 @@ ensure_clean) import pandas.util.testing as tm -from .common import TestData - class SharedWithSparse(object): """ @@ -33,82 +31,82 @@ def _assert_series_equal(self, left, right): """Dispatch to series class dependent assertion""" raise NotImplementedError - def test_scalarop_preserve_name(self): - result = self.ts * 2 - assert result.name == self.ts.name + def test_scalarop_preserve_name(self, datetime_series): + result = datetime_series * 2 + assert result.name == datetime_series.name - def test_copy_name(self): - result = self.ts.copy() - assert result.name == self.ts.name + def test_copy_name(self, datetime_series): + result = datetime_series.copy() + assert result.name == datetime_series.name - def test_copy_index_name_checking(self): + def test_copy_index_name_checking(self, datetime_series): # don't want to be able to modify the index stored elsewhere after # making a copy - self.ts.index.name = None - assert self.ts.index.name is None - assert self.ts is self.ts + datetime_series.index.name = None + assert datetime_series.index.name is None + assert datetime_series is datetime_series - cp = self.ts.copy() + cp = datetime_series.copy() cp.index.name = 'foo' - printing.pprint_thing(self.ts.index.name) - assert self.ts.index.name is None + printing.pprint_thing(datetime_series.index.name) + assert datetime_series.index.name is None - def test_append_preserve_name(self): - result = self.ts[:5].append(self.ts[5:]) - assert result.name == self.ts.name + def test_append_preserve_name(self, datetime_series): + result = datetime_series[:5].append(datetime_series[5:]) + assert result.name == datetime_series.name - def test_binop_maybe_preserve_name(self): + def test_binop_maybe_preserve_name(self, datetime_series): # names match, preserve - result = self.ts * self.ts - assert result.name == self.ts.name - result = self.ts.mul(self.ts) - assert result.name == self.ts.name + result = datetime_series * datetime_series + assert result.name == datetime_series.name + result = datetime_series.mul(datetime_series) + assert result.name == datetime_series.name - result = self.ts * self.ts[:-2] - assert result.name == self.ts.name + result = datetime_series * datetime_series[:-2] + assert result.name == datetime_series.name # names don't match, don't preserve - cp = self.ts.copy() + cp = datetime_series.copy() cp.name = 'something else' - result = self.ts + cp + result = datetime_series + cp assert result.name is None - result = self.ts.add(cp) + result = datetime_series.add(cp) assert result.name is None ops = ['add', 'sub', 'mul', 'div', 'truediv', 'floordiv', 'mod', 'pow'] ops = ops + ['r' + op for op in ops] for op in ops: # names match, preserve - s = self.ts.copy() + s = datetime_series.copy() result = getattr(s, op)(s) - assert result.name == self.ts.name + assert result.name == datetime_series.name # names don't match, don't preserve - cp = self.ts.copy() + cp = datetime_series.copy() cp.name = 'changed' result = getattr(s, op)(cp) assert result.name is None - def test_combine_first_name(self): - result = self.ts.combine_first(self.ts[:5]) - assert result.name == self.ts.name + def test_combine_first_name(self, datetime_series): + result = datetime_series.combine_first(datetime_series[:5]) + assert result.name == datetime_series.name - def test_getitem_preserve_name(self): - result = self.ts[self.ts > 0] - assert result.name == self.ts.name + def test_getitem_preserve_name(self, datetime_series): + result = datetime_series[datetime_series > 0] + assert result.name == datetime_series.name - result = self.ts[[0, 2, 4]] - assert result.name == self.ts.name + result = datetime_series[[0, 2, 4]] + assert result.name == datetime_series.name - result = self.ts[5:10] - assert result.name == self.ts.name + result = datetime_series[5:10] + assert result.name == datetime_series.name - def test_pickle(self): - unp_series = self._pickle_roundtrip(self.series) - unp_ts = self._pickle_roundtrip(self.ts) - assert_series_equal(unp_series, self.series) - assert_series_equal(unp_ts, self.ts) + def test_pickle(self, datetime_series, string_series): + unp_series = self._pickle_roundtrip(string_series) + unp_ts = self._pickle_roundtrip(datetime_series) + assert_series_equal(unp_series, string_series) + assert_series_equal(unp_ts, datetime_series) def _pickle_roundtrip(self, obj): @@ -117,17 +115,17 @@ def _pickle_roundtrip(self, obj): unpickled = pd.read_pickle(path) return unpickled - def test_argsort_preserve_name(self): - result = self.ts.argsort() - assert result.name == self.ts.name + def test_argsort_preserve_name(self, datetime_series): + result = datetime_series.argsort() + assert result.name == datetime_series.name - def test_sort_index_name(self): - result = self.ts.sort_index(ascending=False) - assert result.name == self.ts.name + def test_sort_index_name(self, datetime_series): + result = datetime_series.sort_index(ascending=False) + assert result.name == datetime_series.name - def test_to_sparse_pass_name(self): - result = self.ts.to_sparse() - assert result.name == self.ts.name + def test_to_sparse_pass_name(self, datetime_series): + result = datetime_series.to_sparse() + assert result.name == datetime_series.name def test_constructor_dict(self): d = {'a': 0., 'b': 1., 'c': 2.} @@ -203,7 +201,7 @@ def test_from_array_deprecated(self): self.series_klass.from_array([1, 2, 3]) -class TestSeriesMisc(TestData, SharedWithSparse): +class TestSeriesMisc(SharedWithSparse): series_klass = Series # SharedWithSparse tests use generic, series_klass-agnostic assertion @@ -278,50 +276,50 @@ def test_index_tab_completion(self, index): else: assert x not in dir_s - def test_not_hashable(self): - s_empty = Series() + def test_not_hashable(self, empty_series): s = Series([1]) - pytest.raises(TypeError, hash, s_empty) + pytest.raises(TypeError, hash, empty_series) pytest.raises(TypeError, hash, s) - def test_contains(self): - tm.assert_contains_all(self.ts.index, self.ts) + def test_contains(self, datetime_series): + tm.assert_contains_all(datetime_series.index, datetime_series) - def test_iter(self): - for i, val in enumerate(self.series): - assert val == self.series[i] + def test_iter(self, datetime_series, string_series): + for i, val in enumerate(string_series): + assert val == string_series[i] - for i, val in enumerate(self.ts): - assert val == self.ts[i] + for i, val in enumerate(datetime_series): + assert val == datetime_series[i] - def test_keys(self): + def test_keys(self, datetime_series): # HACK: By doing this in two stages, we avoid 2to3 wrapping the call # to .keys() in a list() - getkeys = self.ts.keys - assert getkeys() is self.ts.index + getkeys = datetime_series.keys + assert getkeys() is datetime_series.index - def test_values(self): - tm.assert_almost_equal(self.ts.values, self.ts, check_dtype=False) + def test_values(self, datetime_series): + tm.assert_almost_equal(datetime_series.values, + datetime_series, check_dtype=False) - def test_iteritems(self): - for idx, val in compat.iteritems(self.series): - assert val == self.series[idx] + def test_iteritems(self, datetime_series, string_series): + for idx, val in compat.iteritems(string_series): + assert val == string_series[idx] - for idx, val in compat.iteritems(self.ts): - assert val == self.ts[idx] + for idx, val in compat.iteritems(datetime_series): + assert val == datetime_series[idx] # assert is lazy (genrators don't define reverse, lists do) - assert not hasattr(self.series.iteritems(), 'reverse') + assert not hasattr(string_series.iteritems(), 'reverse') - def test_items(self): - for idx, val in self.series.items(): - assert val == self.series[idx] + def test_items(self, datetime_series, string_series): + for idx, val in string_series.items(): + assert val == string_series[idx] - for idx, val in self.ts.items(): - assert val == self.ts[idx] + for idx, val in datetime_series.items(): + assert val == datetime_series[idx] # assert is lazy (genrators don't define reverse, lists do) - assert not hasattr(self.series.items(), 'reverse') + assert not hasattr(string_series.items(), 'reverse') def test_raise_on_info(self): s = Series(np.random.randn(10)) @@ -388,9 +386,9 @@ def test_class_axis(self): # no exception and no empty docstring assert pydoc.getdoc(Series.index) - def test_numpy_unique(self): + def test_numpy_unique(self, datetime_series): # it works! - np.unique(self.ts) + np.unique(datetime_series) def test_ndarray_compat(self): From dd016cb4b86218b917a1c77bd47955ce2de65011 Mon Sep 17 00:00:00 2001 From: Anjali Singhal Date: Wed, 19 Sep 2018 19:49:04 +0200 Subject: [PATCH 6/8] TST: Fixturize series/test_apply.py --- pandas/tests/series/test_apply.py | 99 ++++++++++++++++--------------- 1 file changed, 50 insertions(+), 49 deletions(-) diff --git a/pandas/tests/series/test_apply.py b/pandas/tests/series/test_apply.py index b717d75d835d0..20215279cf031 100644 --- a/pandas/tests/series/test_apply.py +++ b/pandas/tests/series/test_apply.py @@ -17,18 +17,18 @@ import pandas.util.testing as tm from pandas.conftest import _get_cython_table_params -from .common import TestData +class TestSeriesApply(): -class TestSeriesApply(TestData): - - def test_apply(self): + def test_apply(self, datetime_series): with np.errstate(all='ignore'): - tm.assert_series_equal(self.ts.apply(np.sqrt), np.sqrt(self.ts)) + tm.assert_series_equal(datetime_series.apply(np.sqrt), + np.sqrt(datetime_series)) # element-wise apply import math - tm.assert_series_equal(self.ts.apply(math.exp), np.exp(self.ts)) + tm.assert_series_equal(datetime_series.apply(math.exp), + np.exp(datetime_series)) # empty series s = Series(dtype=object, name='foo', index=pd.Index([], name='bar')) @@ -66,11 +66,11 @@ def test_apply_dont_convert_dtype(self): result = s.apply(f, convert_dtype=False) assert result.dtype == object - def test_with_string_args(self): + def test_with_string_args(self, datetime_series): for arg in ['sum', 'mean', 'min', 'max', 'std']: - result = self.ts.apply(arg) - expected = getattr(self.ts, arg)() + result = datetime_series.apply(arg) + expected = getattr(datetime_series, arg)() assert result == expected def test_apply_args(self): @@ -165,34 +165,34 @@ def test_apply_dict_depr(self): tsdf.A.agg({'foo': ['sum', 'mean']}) -class TestSeriesAggregate(TestData): +class TestSeriesAggregate(): - def test_transform(self): + def test_transform(self, string_series): # transforming functions with np.errstate(all='ignore'): - f_sqrt = np.sqrt(self.series) - f_abs = np.abs(self.series) + f_sqrt = np.sqrt(string_series) + f_abs = np.abs(string_series) # ufunc - result = self.series.transform(np.sqrt) + result = string_series.transform(np.sqrt) expected = f_sqrt.copy() assert_series_equal(result, expected) - result = self.series.apply(np.sqrt) + result = string_series.apply(np.sqrt) assert_series_equal(result, expected) # list-like - result = self.series.transform([np.sqrt]) + result = string_series.transform([np.sqrt]) expected = f_sqrt.to_frame().copy() expected.columns = ['sqrt'] assert_frame_equal(result, expected) - result = self.series.transform([np.sqrt]) + result = string_series.transform([np.sqrt]) assert_frame_equal(result, expected) - result = self.series.transform(['sqrt']) + result = string_series.transform(['sqrt']) assert_frame_equal(result, expected) # multiple items in list @@ -200,10 +200,10 @@ def test_transform(self): # series and then concatting expected = pd.concat([f_sqrt, f_abs], axis=1) expected.columns = ['sqrt', 'absolute'] - result = self.series.apply([np.sqrt, np.abs]) + result = string_series.apply([np.sqrt, np.abs]) assert_frame_equal(result, expected) - result = self.series.transform(['sqrt', 'abs']) + result = string_series.transform(['sqrt', 'abs']) expected.columns = ['sqrt', 'abs'] assert_frame_equal(result, expected) @@ -212,28 +212,28 @@ def test_transform(self): expected.columns = ['foo', 'bar'] expected = expected.unstack().rename('series') - result = self.series.apply({'foo': np.sqrt, 'bar': np.abs}) + result = string_series.apply({'foo': np.sqrt, 'bar': np.abs}) assert_series_equal(result.reindex_like(expected), expected) - def test_transform_and_agg_error(self): + def test_transform_and_agg_error(self, string_series): # we are trying to transform with an aggregator def f(): - self.series.transform(['min', 'max']) + string_series.transform(['min', 'max']) pytest.raises(ValueError, f) def f(): with np.errstate(all='ignore'): - self.series.agg(['sqrt', 'max']) + string_series.agg(['sqrt', 'max']) pytest.raises(ValueError, f) def f(): with np.errstate(all='ignore'): - self.series.transform(['sqrt', 'max']) + string_series.transform(['sqrt', 'max']) pytest.raises(ValueError, f) def f(): with np.errstate(all='ignore'): - self.series.agg({'foo': np.sqrt, 'bar': 'sum'}) + string_series.agg({'foo': np.sqrt, 'bar': 'sum'}) pytest.raises(ValueError, f) def test_demo(self): @@ -272,33 +272,34 @@ def test_multiple_aggregators_with_dict_api(self): 'min', 'sum']).unstack().rename('series') tm.assert_series_equal(result.reindex_like(expected), expected) - def test_agg_apply_evaluate_lambdas_the_same(self): + def test_agg_apply_evaluate_lambdas_the_same(self, string_series): # test that we are evaluating row-by-row first # before vectorized evaluation - result = self.series.apply(lambda x: str(x)) - expected = self.series.agg(lambda x: str(x)) + result = string_series.apply(lambda x: str(x)) + expected = string_series.agg(lambda x: str(x)) tm.assert_series_equal(result, expected) - result = self.series.apply(str) - expected = self.series.agg(str) + result = string_series.apply(str) + expected = string_series.agg(str) tm.assert_series_equal(result, expected) - def test_with_nested_series(self): + def test_with_nested_series(self, datetime_series): # GH 2316 # .agg with a reducer and a transform, what to do - result = self.ts.apply(lambda x: Series( + result = datetime_series.apply(lambda x: Series( [x, x ** 2], index=['x', 'x^2'])) - expected = DataFrame({'x': self.ts, 'x^2': self.ts ** 2}) + expected = DataFrame({'x': datetime_series, + 'x^2': datetime_series ** 2}) tm.assert_frame_equal(result, expected) - result = self.ts.agg(lambda x: Series( + result = datetime_series.agg(lambda x: Series( [x, x ** 2], index=['x', 'x^2'])) tm.assert_frame_equal(result, expected) - def test_replicate_describe(self): + def test_replicate_describe(self, string_series): # this also tests a result set that is all scalars - expected = self.series.describe() - result = self.series.apply(OrderedDict( + expected = string_series.describe() + result = string_series.apply(OrderedDict( [('count', 'count'), ('mean', 'mean'), ('std', 'std'), @@ -309,13 +310,13 @@ def test_replicate_describe(self): ('max', 'max')])) assert_series_equal(result, expected) - def test_reduce(self): + def test_reduce(self, string_series): # reductions with named functions - result = self.series.agg(['sum', 'mean']) - expected = Series([self.series.sum(), - self.series.mean()], + result = string_series.agg(['sum', 'mean']) + expected = Series([string_series.sum(), + string_series.mean()], ['sum', 'mean'], - name=self.series.name) + name=string_series.name) assert_series_equal(result, expected) def test_non_callable_aggregates(self): @@ -414,9 +415,9 @@ def test_agg_cython_table_raises(self, series, func, expected): series.agg(func) -class TestSeriesMap(TestData): +class TestSeriesMap(): - def test_map(self): + def test_map(self, datetime_series): index, data = tm.getMixedTypeDict() source = Series(data['B'], index=data['C']) @@ -434,8 +435,8 @@ def test_map(self): assert v == source[target[k]] # function - result = self.ts.map(lambda x: x * 2) - tm.assert_series_equal(result, self.ts * 2) + result = datetime_series.map(lambda x: x * 2) + tm.assert_series_equal(result, datetime_series * 2) # GH 10324 a = Series([1, 2, 3, 4]) @@ -500,10 +501,10 @@ def test_map_type_inference(self): s2 = s.map(lambda x: np.where(x == 0, 0, 1)) assert issubclass(s2.dtype.type, np.integer) - def test_map_decimal(self): + def test_map_decimal(self, string_series): from decimal import Decimal - result = self.series.map(lambda x: Decimal(str(x))) + result = string_series.map(lambda x: Decimal(str(x))) assert result.dtype == np.object_ assert isinstance(result[0], Decimal) From a9934c2e5b51fbdab917e7560dc441f305aaf643 Mon Sep 17 00:00:00 2001 From: Anjali Singhal Date: Wed, 19 Sep 2018 19:56:46 +0200 Subject: [PATCH 7/8] TST: Fixturize series/test_arithmetic.py --- pandas/tests/series/test_arithmetic.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/pandas/tests/series/test_arithmetic.py b/pandas/tests/series/test_arithmetic.py index 37ba1c91368b3..b29eb6f62f96f 100644 --- a/pandas/tests/series/test_arithmetic.py +++ b/pandas/tests/series/test_arithmetic.py @@ -24,13 +24,12 @@ def test_ser_flex_cmp_return_dtypes(self, opname): tm.assert_series_equal(result, Series([1], ['bool'])) @pytest.mark.parametrize('opname', ['eq', 'ne', 'gt', 'lt', 'ge', 'le']) - def test_ser_flex_cmp_return_dtypes_empty(self, opname): + def test_ser_flex_cmp_return_dtypes_empty(self, opname, empty_series): # GH#15115 empty Series case ser = Series([1, 3, 2], index=range(3)) - empty = ser.iloc[:0] const = 2 - result = getattr(empty, opname)(const).get_dtype_counts() + result = getattr(empty_series, opname)(const).get_dtype_counts() tm.assert_series_equal(result, Series([1], ['bool'])) @pytest.mark.parametrize('op', [operator.eq, operator.ne, From 05f38b978dd1d11f920db9813655f1a086fde243 Mon Sep 17 00:00:00 2001 From: Anjali Singhal Date: Sun, 23 Sep 2018 12:58:30 +0200 Subject: [PATCH 8/8] Revert unrelated test changes --- pandas/tests/series/test_analytics.py | 225 +++++++++++++------------- pandas/tests/series/test_api.py | 168 +++++++++---------- pandas/tests/series/test_apply.py | 99 ++++++------ pandas/tests/series/test_validate.py | 11 +- 4 files changed, 253 insertions(+), 250 deletions(-) diff --git a/pandas/tests/series/test_analytics.py b/pandas/tests/series/test_analytics.py index 3fec2c6a3baba..d5d9e5f4f14de 100644 --- a/pandas/tests/series/test_analytics.py +++ b/pandas/tests/series/test_analytics.py @@ -24,9 +24,10 @@ assert_frame_equal, assert_index_equal) import pandas.util.testing as tm import pandas.util._test_decorators as td +from .common import TestData -class TestSeriesAnalytics(): +class TestSeriesAnalytics(TestData): @pytest.mark.parametrize("use_bottleneck", [True, False]) @pytest.mark.parametrize("method, unit", [ @@ -193,8 +194,8 @@ def test_sum_overflow(self, use_bottleneck): result = s.max(skipna=False) assert np.allclose(float(result), v[-1]) - def test_sum(self, string_series): - self._check_stat_op('sum', np.sum, string_series, check_allna=False) + def test_sum(self): + self._check_stat_op('sum', np.sum, check_allna=False) def test_sum_inf(self): s = Series(np.random.randn(10)) @@ -214,67 +215,67 @@ def test_sum_inf(self): res = nanops.nansum(arr, axis=1) assert np.isinf(res).all() - def test_mean(self, string_series): - self._check_stat_op('mean', np.mean, string_series) + def test_mean(self): + self._check_stat_op('mean', np.mean) - def test_median(self, string_series): - self._check_stat_op('median', np.median, string_series) + def test_median(self): + self._check_stat_op('median', np.median) # test with integers, test failure int_ts = Series(np.ones(10, dtype=int), index=lrange(10)) tm.assert_almost_equal(np.median(int_ts), int_ts.median()) - def test_prod(self, string_series): - self._check_stat_op('prod', np.prod, string_series) + def test_prod(self): + self._check_stat_op('prod', np.prod) - def test_min(self, string_series): - self._check_stat_op('min', np.min, string_series, check_objects=True) + def test_min(self): + self._check_stat_op('min', np.min, check_objects=True) - def test_max(self, string_series): - self._check_stat_op('max', np.max, string_series, check_objects=True) + def test_max(self): + self._check_stat_op('max', np.max, check_objects=True) - def test_var_std(self, datetime_series, string_series): + def test_var_std(self): alt = lambda x: np.std(x, ddof=1) - self._check_stat_op('std', alt, string_series) + self._check_stat_op('std', alt) alt = lambda x: np.var(x, ddof=1) - self._check_stat_op('var', alt, string_series) + self._check_stat_op('var', alt) - result = datetime_series.std(ddof=4) - expected = np.std(datetime_series.values, ddof=4) + result = self.ts.std(ddof=4) + expected = np.std(self.ts.values, ddof=4) assert_almost_equal(result, expected) - result = datetime_series.var(ddof=4) - expected = np.var(datetime_series.values, ddof=4) + result = self.ts.var(ddof=4) + expected = np.var(self.ts.values, ddof=4) assert_almost_equal(result, expected) # 1 - element series with ddof=1 - s = datetime_series.iloc[[0]] + s = self.ts.iloc[[0]] result = s.var(ddof=1) assert isna(result) result = s.std(ddof=1) assert isna(result) - def test_sem(self, datetime_series, string_series): + def test_sem(self): alt = lambda x: np.std(x, ddof=1) / np.sqrt(len(x)) - self._check_stat_op('sem', alt, string_series) + self._check_stat_op('sem', alt) - result = datetime_series.sem(ddof=4) - expected = np.std(datetime_series.values, - ddof=4) / np.sqrt(len(datetime_series.values)) + result = self.ts.sem(ddof=4) + expected = np.std(self.ts.values, + ddof=4) / np.sqrt(len(self.ts.values)) assert_almost_equal(result, expected) # 1 - element series with ddof=1 - s = datetime_series.iloc[[0]] + s = self.ts.iloc[[0]] result = s.sem(ddof=1) assert isna(result) @td.skip_if_no_scipy - def test_skew(self, string_series): + def test_skew(self): from scipy.stats import skew alt = lambda x: skew(x, bias=False) - self._check_stat_op('skew', alt, string_series) + self._check_stat_op('skew', alt) # test corner cases, skew() returns NaN unless there's at least 3 # values @@ -290,10 +291,10 @@ def test_skew(self, string_series): assert (df.skew() == 0).all() @td.skip_if_no_scipy - def test_kurt(self, string_series): + def test_kurt(self): from scipy.stats import kurtosis alt = lambda x: kurtosis(x, bias=False) - self._check_stat_op('kurt', alt, string_series) + self._check_stat_op('kurt', alt) index = MultiIndex(levels=[['bar'], ['one', 'two', 'three'], [0, 1]], labels=[[0, 0, 0, 0, 0, 0], [0, 1, 2, 0, 1, 2], @@ -352,9 +353,9 @@ def test_describe_with_tz(self, tz_naive_fixture): ) tm.assert_series_equal(result, expected) - def test_argsort(self, datetime_series): - self._check_accum_op('argsort', datetime_series, check_dtype=False) - argsorted = datetime_series.argsort() + def test_argsort(self): + self._check_accum_op('argsort', check_dtype=False) + argsorted = self.ts.argsort() assert issubclass(argsorted.dtype.type, np.integer) # GH 2967 (introduced bug in 0.11-dev I think) @@ -387,28 +388,26 @@ def test_argsort_stable(self): pytest.raises(AssertionError, tm.assert_numpy_array_equal, qindexer, mindexer) - def test_cumsum(self, datetime_series): - self._check_accum_op('cumsum', datetime_series) + def test_cumsum(self): + self._check_accum_op('cumsum') - def test_cumprod(self, datetime_series): - self._check_accum_op('cumprod', datetime_series) + def test_cumprod(self): + self._check_accum_op('cumprod') - def test_cummin(self, datetime_series): - tm.assert_numpy_array_equal(datetime_series.cummin().values, - np.minimum - .accumulate(np.array(datetime_series))) - ts = datetime_series.copy() + def test_cummin(self): + tm.assert_numpy_array_equal(self.ts.cummin().values, + np.minimum.accumulate(np.array(self.ts))) + ts = self.ts.copy() ts[::2] = np.NaN result = ts.cummin()[1::2] expected = np.minimum.accumulate(ts.dropna()) tm.assert_series_equal(result, expected) - def test_cummax(self, datetime_series): - tm.assert_numpy_array_equal(datetime_series.cummax().values, - np.maximum - .accumulate(np.array(datetime_series))) - ts = datetime_series.copy() + def test_cummax(self): + tm.assert_numpy_array_equal(self.ts.cummax().values, + np.maximum.accumulate(np.array(self.ts))) + ts = self.ts.copy() ts[::2] = np.NaN result = ts.cummax()[1::2] expected = np.maximum.accumulate(ts.dropna()) @@ -507,14 +506,14 @@ def test_npdiff(self): r = np.diff(s) assert_series_equal(Series([nan, 0, 0, 0, nan]), r) - def _check_stat_op(self, name, alternate, string_series_, - check_objects=False, check_allna=False): + def _check_stat_op(self, name, alternate, check_objects=False, + check_allna=False): with pd.option_context('use_bottleneck', False): f = getattr(Series, name) # add some NaNs - string_series_[5:15] = np.NaN + self.series[5:15] = np.NaN # idxmax, idxmin, min, and max are valid for dates if name not in ['max', 'min']: @@ -522,15 +521,15 @@ def _check_stat_op(self, name, alternate, string_series_, pytest.raises(TypeError, f, ds) # skipna or no - assert notna(f(string_series_)) - assert isna(f(string_series_, skipna=False)) + assert notna(f(self.series)) + assert isna(f(self.series, skipna=False)) # check the result is correct - nona = string_series_.dropna() + nona = self.series.dropna() assert_almost_equal(f(nona), alternate(nona.values)) - assert_almost_equal(f(string_series_), alternate(nona.values)) + assert_almost_equal(f(self.series), alternate(nona.values)) - allna = string_series_ * nan + allna = self.series * nan if check_allna: assert np.isnan(f(allna)) @@ -557,21 +556,21 @@ def _check_stat_op(self, name, alternate, string_series_, pytest.raises(TypeError, f, Series(list('abc'))) # Invalid axis. - pytest.raises(ValueError, f, string_series_, axis=1) + pytest.raises(ValueError, f, self.series, axis=1) # Unimplemented numeric_only parameter. if 'numeric_only' in compat.signature(f).args: tm.assert_raises_regex(NotImplementedError, name, f, - string_series_, numeric_only=True) + self.series, numeric_only=True) - def _check_accum_op(self, name, datetime_series_, check_dtype=True): + def _check_accum_op(self, name, check_dtype=True): func = getattr(np, name) - tm.assert_numpy_array_equal(func(datetime_series_).values, - func(np.array(datetime_series_)), + tm.assert_numpy_array_equal(func(self.ts).values, + func(np.array(self.ts)), check_dtype=check_dtype) # with missing values - ts = datetime_series_.copy() + ts = self.ts.copy() ts[::2] = np.NaN result = func(ts)[1::2] @@ -608,13 +607,13 @@ def test_numpy_compress(self): tm.assert_raises_regex(ValueError, msg, np.compress, cond, s, out=s) - def test_round(self, datetime_series): - datetime_series.index.name = "index_name" - result = datetime_series.round(2) - expected = Series(np.round(datetime_series.values, 2), - index=datetime_series.index, name='ts') + def test_round(self): + self.ts.index.name = "index_name" + result = self.ts.round(2) + expected = Series(np.round(self.ts.values, 2), + index=self.ts.index, name='ts') assert_series_equal(result, expected) - assert result.name == datetime_series.name + assert result.name == self.ts.name def test_numpy_round(self): # See gh-12600 @@ -718,28 +717,26 @@ def test_modulo(self): assert_series_equal(result, expected) @td.skip_if_no_scipy - def test_corr(self, datetime_series): + def test_corr(self): import scipy.stats as stats # full overlap - tm.assert_almost_equal(datetime_series.corr(datetime_series), 1) + tm.assert_almost_equal(self.ts.corr(self.ts), 1) # partial overlap - tm.assert_almost_equal(datetime_series[:15].corr(datetime_series[5:]), - 1) + tm.assert_almost_equal(self.ts[:15].corr(self.ts[5:]), 1) - assert isna(datetime_series[:15].corr(datetime_series[5:], - min_periods=12)) + assert isna(self.ts[:15].corr(self.ts[5:], min_periods=12)) - ts1 = datetime_series[:15].reindex(datetime_series.index) - ts2 = datetime_series[5:].reindex(datetime_series.index) + ts1 = self.ts[:15].reindex(self.ts.index) + ts2 = self.ts[5:].reindex(self.ts.index) assert isna(ts1.corr(ts2, min_periods=12)) # No overlap - assert np.isnan(datetime_series[::2].corr(datetime_series[1::2])) + assert np.isnan(self.ts[::2].corr(self.ts[1::2])) # all NA - cp = datetime_series[:10].copy() + cp = self.ts[:10].copy() cp[:] = np.nan assert isna(cp.corr(cp)) @@ -792,37 +789,35 @@ def test_corr_invalid_method(self): with tm.assert_raises_regex(ValueError, msg): s1.corr(s2, method="____") - def test_cov(self, datetime_series): + def test_cov(self): # full overlap - tm.assert_almost_equal(datetime_series.cov(datetime_series), - datetime_series.std() ** 2) + tm.assert_almost_equal(self.ts.cov(self.ts), self.ts.std() ** 2) # partial overlap - tm.assert_almost_equal(datetime_series[:15].cov(datetime_series[5:]), - datetime_series[5:15].std() ** 2) + tm.assert_almost_equal(self.ts[:15].cov(self.ts[5:]), + self.ts[5:15].std() ** 2) # No overlap - assert np.isnan(datetime_series[::2].cov(datetime_series[1::2])) + assert np.isnan(self.ts[::2].cov(self.ts[1::2])) # all NA - cp = datetime_series[:10].copy() + cp = self.ts[:10].copy() cp[:] = np.nan assert isna(cp.cov(cp)) # min_periods - assert isna(datetime_series[:15].cov(datetime_series[5:], - min_periods=12)) + assert isna(self.ts[:15].cov(self.ts[5:], min_periods=12)) - ts1 = datetime_series[:15].reindex(datetime_series.index) - ts2 = datetime_series[5:].reindex(datetime_series.index) + ts1 = self.ts[:15].reindex(self.ts.index) + ts2 = self.ts[5:].reindex(self.ts.index) assert isna(ts1.cov(ts2, min_periods=12)) - def test_count(self, datetime_series): - assert datetime_series.count() == len(datetime_series) + def test_count(self): + assert self.ts.count() == len(self.ts) - datetime_series[::2] = np.NaN + self.ts[::2] = np.NaN - assert datetime_series.count() == np.isfinite(datetime_series).sum() + assert self.ts.count() == np.isfinite(self.ts).sum() mi = MultiIndex.from_arrays([list('aabbcc'), [1, 2, 2, nan, 1, 2]]) ts = Series(np.arange(len(mi)), index=mi) @@ -925,17 +920,17 @@ def test_matmul(self): pytest.raises(Exception, a.dot, a.values[:3]) pytest.raises(ValueError, a.dot, b.T) - def test_clip(self, datetime_series): - val = datetime_series.median() + def test_clip(self): + val = self.ts.median() - assert datetime_series.clip_lower(val).min() == val - assert datetime_series.clip_upper(val).max() == val + assert self.ts.clip_lower(val).min() == val + assert self.ts.clip_upper(val).max() == val - assert datetime_series.clip(lower=val).min() == val - assert datetime_series.clip(upper=val).max() == val + assert self.ts.clip(lower=val).min() == val + assert self.ts.clip(upper=val).max() == val - result = datetime_series.clip(-0.5, 0.5) - expected = np.clip(datetime_series, -0.5, 0.5) + result = self.ts.clip(-0.5, 0.5) + expected = np.clip(self.ts, -0.5, 0.5) assert_series_equal(result, expected) assert isinstance(expected, Series) @@ -1169,25 +1164,25 @@ def test_timedelta64_analytics(self): expected = Timedelta('1 days') assert result == expected - def test_idxmin(self, string_series): + def test_idxmin(self): # test idxmin # _check_stat_op approach can not be used here because of isna check. # add some NaNs - string_series[5:15] = np.NaN + self.series[5:15] = np.NaN # skipna or no - assert string_series[string_series.idxmin()] == string_series.min() - assert isna(string_series.idxmin(skipna=False)) + assert self.series[self.series.idxmin()] == self.series.min() + assert isna(self.series.idxmin(skipna=False)) # no NaNs - nona = string_series.dropna() + nona = self.series.dropna() assert nona[nona.idxmin()] == nona.min() assert (nona.index.values.tolist().index(nona.idxmin()) == nona.values.argmin()) # all NaNs - allna = string_series * nan + allna = self.series * nan assert isna(allna.idxmin()) # datetime64[ns] @@ -1226,25 +1221,25 @@ def test_numpy_argmin_deprecated(self): tm.assert_raises_regex(ValueError, msg, np.argmin, s, out=data) - def test_idxmax(self, string_series): + def test_idxmax(self): # test idxmax # _check_stat_op approach can not be used here because of isna check. # add some NaNs - string_series[5:15] = np.NaN + self.series[5:15] = np.NaN # skipna or no - assert string_series[string_series.idxmax()] == string_series.max() - assert isna(string_series.idxmax(skipna=False)) + assert self.series[self.series.idxmax()] == self.series.max() + assert isna(self.series.idxmax(skipna=False)) # no NaNs - nona = string_series.dropna() + nona = self.series.dropna() assert nona[nona.idxmax()] == nona.max() assert (nona.index.values.tolist().index(nona.idxmax()) == nona.values.argmax()) # all NaNs - allna = string_series * nan + allna = self.series * nan assert isna(allna.idxmax()) from pandas import date_range @@ -1463,8 +1458,8 @@ def test_apply_categorical(self): tm.assert_series_equal(result, exp) assert result.dtype == np.object - def test_shift_int(self, datetime_series): - ts = datetime_series.astype(int) + def test_shift_int(self): + ts = self.ts.astype(int) shifted = ts.shift(1) expected = ts.astype(float).shift(1) assert_series_equal(shifted, expected) diff --git a/pandas/tests/series/test_api.py b/pandas/tests/series/test_api.py index b6f32f2efa46c..da9b03e81994d 100644 --- a/pandas/tests/series/test_api.py +++ b/pandas/tests/series/test_api.py @@ -19,6 +19,8 @@ ensure_clean) import pandas.util.testing as tm +from .common import TestData + class SharedWithSparse(object): """ @@ -31,82 +33,82 @@ def _assert_series_equal(self, left, right): """Dispatch to series class dependent assertion""" raise NotImplementedError - def test_scalarop_preserve_name(self, datetime_series): - result = datetime_series * 2 - assert result.name == datetime_series.name + def test_scalarop_preserve_name(self): + result = self.ts * 2 + assert result.name == self.ts.name - def test_copy_name(self, datetime_series): - result = datetime_series.copy() - assert result.name == datetime_series.name + def test_copy_name(self): + result = self.ts.copy() + assert result.name == self.ts.name - def test_copy_index_name_checking(self, datetime_series): + def test_copy_index_name_checking(self): # don't want to be able to modify the index stored elsewhere after # making a copy - datetime_series.index.name = None - assert datetime_series.index.name is None - assert datetime_series is datetime_series + self.ts.index.name = None + assert self.ts.index.name is None + assert self.ts is self.ts - cp = datetime_series.copy() + cp = self.ts.copy() cp.index.name = 'foo' - printing.pprint_thing(datetime_series.index.name) - assert datetime_series.index.name is None + printing.pprint_thing(self.ts.index.name) + assert self.ts.index.name is None - def test_append_preserve_name(self, datetime_series): - result = datetime_series[:5].append(datetime_series[5:]) - assert result.name == datetime_series.name + def test_append_preserve_name(self): + result = self.ts[:5].append(self.ts[5:]) + assert result.name == self.ts.name - def test_binop_maybe_preserve_name(self, datetime_series): + def test_binop_maybe_preserve_name(self): # names match, preserve - result = datetime_series * datetime_series - assert result.name == datetime_series.name - result = datetime_series.mul(datetime_series) - assert result.name == datetime_series.name + result = self.ts * self.ts + assert result.name == self.ts.name + result = self.ts.mul(self.ts) + assert result.name == self.ts.name - result = datetime_series * datetime_series[:-2] - assert result.name == datetime_series.name + result = self.ts * self.ts[:-2] + assert result.name == self.ts.name # names don't match, don't preserve - cp = datetime_series.copy() + cp = self.ts.copy() cp.name = 'something else' - result = datetime_series + cp + result = self.ts + cp assert result.name is None - result = datetime_series.add(cp) + result = self.ts.add(cp) assert result.name is None ops = ['add', 'sub', 'mul', 'div', 'truediv', 'floordiv', 'mod', 'pow'] ops = ops + ['r' + op for op in ops] for op in ops: # names match, preserve - s = datetime_series.copy() + s = self.ts.copy() result = getattr(s, op)(s) - assert result.name == datetime_series.name + assert result.name == self.ts.name # names don't match, don't preserve - cp = datetime_series.copy() + cp = self.ts.copy() cp.name = 'changed' result = getattr(s, op)(cp) assert result.name is None - def test_combine_first_name(self, datetime_series): - result = datetime_series.combine_first(datetime_series[:5]) - assert result.name == datetime_series.name + def test_combine_first_name(self): + result = self.ts.combine_first(self.ts[:5]) + assert result.name == self.ts.name - def test_getitem_preserve_name(self, datetime_series): - result = datetime_series[datetime_series > 0] - assert result.name == datetime_series.name + def test_getitem_preserve_name(self): + result = self.ts[self.ts > 0] + assert result.name == self.ts.name - result = datetime_series[[0, 2, 4]] - assert result.name == datetime_series.name + result = self.ts[[0, 2, 4]] + assert result.name == self.ts.name - result = datetime_series[5:10] - assert result.name == datetime_series.name + result = self.ts[5:10] + assert result.name == self.ts.name - def test_pickle(self, datetime_series, string_series): - unp_series = self._pickle_roundtrip(string_series) - unp_ts = self._pickle_roundtrip(datetime_series) - assert_series_equal(unp_series, string_series) - assert_series_equal(unp_ts, datetime_series) + def test_pickle(self): + unp_series = self._pickle_roundtrip(self.series) + unp_ts = self._pickle_roundtrip(self.ts) + assert_series_equal(unp_series, self.series) + assert_series_equal(unp_ts, self.ts) def _pickle_roundtrip(self, obj): @@ -115,17 +117,17 @@ def _pickle_roundtrip(self, obj): unpickled = pd.read_pickle(path) return unpickled - def test_argsort_preserve_name(self, datetime_series): - result = datetime_series.argsort() - assert result.name == datetime_series.name + def test_argsort_preserve_name(self): + result = self.ts.argsort() + assert result.name == self.ts.name - def test_sort_index_name(self, datetime_series): - result = datetime_series.sort_index(ascending=False) - assert result.name == datetime_series.name + def test_sort_index_name(self): + result = self.ts.sort_index(ascending=False) + assert result.name == self.ts.name - def test_to_sparse_pass_name(self, datetime_series): - result = datetime_series.to_sparse() - assert result.name == datetime_series.name + def test_to_sparse_pass_name(self): + result = self.ts.to_sparse() + assert result.name == self.ts.name def test_constructor_dict(self): d = {'a': 0., 'b': 1., 'c': 2.} @@ -201,7 +203,7 @@ def test_from_array_deprecated(self): self.series_klass.from_array([1, 2, 3]) -class TestSeriesMisc(SharedWithSparse): +class TestSeriesMisc(TestData, SharedWithSparse): series_klass = Series # SharedWithSparse tests use generic, series_klass-agnostic assertion @@ -276,50 +278,50 @@ def test_index_tab_completion(self, index): else: assert x not in dir_s - def test_not_hashable(self, empty_series): + def test_not_hashable(self): + s_empty = Series() s = Series([1]) - pytest.raises(TypeError, hash, empty_series) + pytest.raises(TypeError, hash, s_empty) pytest.raises(TypeError, hash, s) - def test_contains(self, datetime_series): - tm.assert_contains_all(datetime_series.index, datetime_series) + def test_contains(self): + tm.assert_contains_all(self.ts.index, self.ts) - def test_iter(self, datetime_series, string_series): - for i, val in enumerate(string_series): - assert val == string_series[i] + def test_iter(self): + for i, val in enumerate(self.series): + assert val == self.series[i] - for i, val in enumerate(datetime_series): - assert val == datetime_series[i] + for i, val in enumerate(self.ts): + assert val == self.ts[i] - def test_keys(self, datetime_series): + def test_keys(self): # HACK: By doing this in two stages, we avoid 2to3 wrapping the call # to .keys() in a list() - getkeys = datetime_series.keys - assert getkeys() is datetime_series.index + getkeys = self.ts.keys + assert getkeys() is self.ts.index - def test_values(self, datetime_series): - tm.assert_almost_equal(datetime_series.values, - datetime_series, check_dtype=False) + def test_values(self): + tm.assert_almost_equal(self.ts.values, self.ts, check_dtype=False) - def test_iteritems(self, datetime_series, string_series): - for idx, val in compat.iteritems(string_series): - assert val == string_series[idx] + def test_iteritems(self): + for idx, val in compat.iteritems(self.series): + assert val == self.series[idx] - for idx, val in compat.iteritems(datetime_series): - assert val == datetime_series[idx] + for idx, val in compat.iteritems(self.ts): + assert val == self.ts[idx] # assert is lazy (genrators don't define reverse, lists do) - assert not hasattr(string_series.iteritems(), 'reverse') + assert not hasattr(self.series.iteritems(), 'reverse') - def test_items(self, datetime_series, string_series): - for idx, val in string_series.items(): - assert val == string_series[idx] + def test_items(self): + for idx, val in self.series.items(): + assert val == self.series[idx] - for idx, val in datetime_series.items(): - assert val == datetime_series[idx] + for idx, val in self.ts.items(): + assert val == self.ts[idx] # assert is lazy (genrators don't define reverse, lists do) - assert not hasattr(string_series.items(), 'reverse') + assert not hasattr(self.series.items(), 'reverse') def test_raise_on_info(self): s = Series(np.random.randn(10)) @@ -386,9 +388,9 @@ def test_class_axis(self): # no exception and no empty docstring assert pydoc.getdoc(Series.index) - def test_numpy_unique(self, datetime_series): + def test_numpy_unique(self): # it works! - np.unique(datetime_series) + np.unique(self.ts) def test_ndarray_compat(self): diff --git a/pandas/tests/series/test_apply.py b/pandas/tests/series/test_apply.py index 20215279cf031..b717d75d835d0 100644 --- a/pandas/tests/series/test_apply.py +++ b/pandas/tests/series/test_apply.py @@ -17,18 +17,18 @@ import pandas.util.testing as tm from pandas.conftest import _get_cython_table_params +from .common import TestData -class TestSeriesApply(): - def test_apply(self, datetime_series): +class TestSeriesApply(TestData): + + def test_apply(self): with np.errstate(all='ignore'): - tm.assert_series_equal(datetime_series.apply(np.sqrt), - np.sqrt(datetime_series)) + tm.assert_series_equal(self.ts.apply(np.sqrt), np.sqrt(self.ts)) # element-wise apply import math - tm.assert_series_equal(datetime_series.apply(math.exp), - np.exp(datetime_series)) + tm.assert_series_equal(self.ts.apply(math.exp), np.exp(self.ts)) # empty series s = Series(dtype=object, name='foo', index=pd.Index([], name='bar')) @@ -66,11 +66,11 @@ def test_apply_dont_convert_dtype(self): result = s.apply(f, convert_dtype=False) assert result.dtype == object - def test_with_string_args(self, datetime_series): + def test_with_string_args(self): for arg in ['sum', 'mean', 'min', 'max', 'std']: - result = datetime_series.apply(arg) - expected = getattr(datetime_series, arg)() + result = self.ts.apply(arg) + expected = getattr(self.ts, arg)() assert result == expected def test_apply_args(self): @@ -165,34 +165,34 @@ def test_apply_dict_depr(self): tsdf.A.agg({'foo': ['sum', 'mean']}) -class TestSeriesAggregate(): +class TestSeriesAggregate(TestData): - def test_transform(self, string_series): + def test_transform(self): # transforming functions with np.errstate(all='ignore'): - f_sqrt = np.sqrt(string_series) - f_abs = np.abs(string_series) + f_sqrt = np.sqrt(self.series) + f_abs = np.abs(self.series) # ufunc - result = string_series.transform(np.sqrt) + result = self.series.transform(np.sqrt) expected = f_sqrt.copy() assert_series_equal(result, expected) - result = string_series.apply(np.sqrt) + result = self.series.apply(np.sqrt) assert_series_equal(result, expected) # list-like - result = string_series.transform([np.sqrt]) + result = self.series.transform([np.sqrt]) expected = f_sqrt.to_frame().copy() expected.columns = ['sqrt'] assert_frame_equal(result, expected) - result = string_series.transform([np.sqrt]) + result = self.series.transform([np.sqrt]) assert_frame_equal(result, expected) - result = string_series.transform(['sqrt']) + result = self.series.transform(['sqrt']) assert_frame_equal(result, expected) # multiple items in list @@ -200,10 +200,10 @@ def test_transform(self, string_series): # series and then concatting expected = pd.concat([f_sqrt, f_abs], axis=1) expected.columns = ['sqrt', 'absolute'] - result = string_series.apply([np.sqrt, np.abs]) + result = self.series.apply([np.sqrt, np.abs]) assert_frame_equal(result, expected) - result = string_series.transform(['sqrt', 'abs']) + result = self.series.transform(['sqrt', 'abs']) expected.columns = ['sqrt', 'abs'] assert_frame_equal(result, expected) @@ -212,28 +212,28 @@ def test_transform(self, string_series): expected.columns = ['foo', 'bar'] expected = expected.unstack().rename('series') - result = string_series.apply({'foo': np.sqrt, 'bar': np.abs}) + result = self.series.apply({'foo': np.sqrt, 'bar': np.abs}) assert_series_equal(result.reindex_like(expected), expected) - def test_transform_and_agg_error(self, string_series): + def test_transform_and_agg_error(self): # we are trying to transform with an aggregator def f(): - string_series.transform(['min', 'max']) + self.series.transform(['min', 'max']) pytest.raises(ValueError, f) def f(): with np.errstate(all='ignore'): - string_series.agg(['sqrt', 'max']) + self.series.agg(['sqrt', 'max']) pytest.raises(ValueError, f) def f(): with np.errstate(all='ignore'): - string_series.transform(['sqrt', 'max']) + self.series.transform(['sqrt', 'max']) pytest.raises(ValueError, f) def f(): with np.errstate(all='ignore'): - string_series.agg({'foo': np.sqrt, 'bar': 'sum'}) + self.series.agg({'foo': np.sqrt, 'bar': 'sum'}) pytest.raises(ValueError, f) def test_demo(self): @@ -272,34 +272,33 @@ def test_multiple_aggregators_with_dict_api(self): 'min', 'sum']).unstack().rename('series') tm.assert_series_equal(result.reindex_like(expected), expected) - def test_agg_apply_evaluate_lambdas_the_same(self, string_series): + def test_agg_apply_evaluate_lambdas_the_same(self): # test that we are evaluating row-by-row first # before vectorized evaluation - result = string_series.apply(lambda x: str(x)) - expected = string_series.agg(lambda x: str(x)) + result = self.series.apply(lambda x: str(x)) + expected = self.series.agg(lambda x: str(x)) tm.assert_series_equal(result, expected) - result = string_series.apply(str) - expected = string_series.agg(str) + result = self.series.apply(str) + expected = self.series.agg(str) tm.assert_series_equal(result, expected) - def test_with_nested_series(self, datetime_series): + def test_with_nested_series(self): # GH 2316 # .agg with a reducer and a transform, what to do - result = datetime_series.apply(lambda x: Series( + result = self.ts.apply(lambda x: Series( [x, x ** 2], index=['x', 'x^2'])) - expected = DataFrame({'x': datetime_series, - 'x^2': datetime_series ** 2}) + expected = DataFrame({'x': self.ts, 'x^2': self.ts ** 2}) tm.assert_frame_equal(result, expected) - result = datetime_series.agg(lambda x: Series( + result = self.ts.agg(lambda x: Series( [x, x ** 2], index=['x', 'x^2'])) tm.assert_frame_equal(result, expected) - def test_replicate_describe(self, string_series): + def test_replicate_describe(self): # this also tests a result set that is all scalars - expected = string_series.describe() - result = string_series.apply(OrderedDict( + expected = self.series.describe() + result = self.series.apply(OrderedDict( [('count', 'count'), ('mean', 'mean'), ('std', 'std'), @@ -310,13 +309,13 @@ def test_replicate_describe(self, string_series): ('max', 'max')])) assert_series_equal(result, expected) - def test_reduce(self, string_series): + def test_reduce(self): # reductions with named functions - result = string_series.agg(['sum', 'mean']) - expected = Series([string_series.sum(), - string_series.mean()], + result = self.series.agg(['sum', 'mean']) + expected = Series([self.series.sum(), + self.series.mean()], ['sum', 'mean'], - name=string_series.name) + name=self.series.name) assert_series_equal(result, expected) def test_non_callable_aggregates(self): @@ -415,9 +414,9 @@ def test_agg_cython_table_raises(self, series, func, expected): series.agg(func) -class TestSeriesMap(): +class TestSeriesMap(TestData): - def test_map(self, datetime_series): + def test_map(self): index, data = tm.getMixedTypeDict() source = Series(data['B'], index=data['C']) @@ -435,8 +434,8 @@ def test_map(self, datetime_series): assert v == source[target[k]] # function - result = datetime_series.map(lambda x: x * 2) - tm.assert_series_equal(result, datetime_series * 2) + result = self.ts.map(lambda x: x * 2) + tm.assert_series_equal(result, self.ts * 2) # GH 10324 a = Series([1, 2, 3, 4]) @@ -501,10 +500,10 @@ def test_map_type_inference(self): s2 = s.map(lambda x: np.where(x == 0, 0, 1)) assert issubclass(s2.dtype.type, np.integer) - def test_map_decimal(self, string_series): + def test_map_decimal(self): from decimal import Decimal - result = string_series.map(lambda x: Decimal(str(x))) + result = self.series.map(lambda x: Decimal(str(x))) assert result.dtype == np.object_ assert isinstance(result[0], Decimal) diff --git a/pandas/tests/series/test_validate.py b/pandas/tests/series/test_validate.py index 8c4b6ee5b1d75..a0cde5f81d021 100644 --- a/pandas/tests/series/test_validate.py +++ b/pandas/tests/series/test_validate.py @@ -1,7 +1,14 @@ +from pandas.core.series import Series + import pytest import pandas.util.testing as tm +@pytest.fixture +def series(): + return Series([1, 2, 3, 4, 5]) + + class TestSeriesValidate(object): """Tests for error handling related to data types of method arguments.""" @@ -9,7 +16,7 @@ class TestSeriesValidate(object): "sort_values", "sort_index", "rename", "dropna"]) @pytest.mark.parametrize("inplace", [1, "True", [1, 2, 3], 5.0]) - def test_validate_bool_args(self, string_series, func, inplace): + def test_validate_bool_args(self, series, func, inplace): msg = "For argument \"inplace\" expected type bool" kwargs = dict(inplace=inplace) @@ -17,4 +24,4 @@ def test_validate_bool_args(self, string_series, func, inplace): kwargs["name"] = "hello" with tm.assert_raises_regex(ValueError, msg): - getattr(string_series, func)(**kwargs) + getattr(series, func)(**kwargs)