From a30de528736d799316394d74636e22fc7de5a30d Mon Sep 17 00:00:00 2001 From: Brock Date: Wed, 28 Oct 2020 10:01:05 -0700 Subject: [PATCH] TST: collect tests by method from test_api --- pandas/tests/series/methods/test_copy.py | 71 ++++++++++ pandas/tests/series/test_api.py | 172 ----------------------- pandas/tests/series/test_arithmetic.py | 38 +++++ pandas/tests/series/test_constructors.py | 62 ++++++++ 4 files changed, 171 insertions(+), 172 deletions(-) create mode 100644 pandas/tests/series/methods/test_copy.py diff --git a/pandas/tests/series/methods/test_copy.py b/pandas/tests/series/methods/test_copy.py new file mode 100644 index 0000000000000..6201c0f5f7c29 --- /dev/null +++ b/pandas/tests/series/methods/test_copy.py @@ -0,0 +1,71 @@ +import numpy as np +import pytest + +from pandas import Series, Timestamp +import pandas._testing as tm + + +class TestCopy: + @pytest.mark.parametrize("deep", [None, False, True]) + def test_copy(self, deep): + + ser = Series(np.arange(10), dtype="float64") + + # default deep is True + if deep is None: + ser2 = ser.copy() + else: + ser2 = ser.copy(deep=deep) + + ser2[::2] = np.NaN + + if deep is None or deep is True: + # Did not modify original Series + assert np.isnan(ser2[0]) + assert not np.isnan(ser[0]) + else: + # we DID modify the original Series + assert np.isnan(ser2[0]) + assert np.isnan(ser[0]) + + @pytest.mark.parametrize("deep", [None, False, True]) + def test_copy_tzaware(self, deep): + # GH#11794 + # copy of tz-aware + expected = Series([Timestamp("2012/01/01", tz="UTC")]) + expected2 = Series([Timestamp("1999/01/01", tz="UTC")]) + + ser = Series([Timestamp("2012/01/01", tz="UTC")]) + + if deep is None: + ser2 = ser.copy() + else: + ser2 = ser.copy(deep=deep) + + ser2[0] = Timestamp("1999/01/01", tz="UTC") + + # default deep is True + if deep is None or deep is True: + # Did not modify original Series + tm.assert_series_equal(ser2, expected2) + tm.assert_series_equal(ser, expected) + else: + # we DID modify the original Series + tm.assert_series_equal(ser2, expected2) + tm.assert_series_equal(ser, expected2) + + def test_copy_name(self, datetime_series): + result = datetime_series.copy() + assert result.name == datetime_series.name + + 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 + + datetime_series.index.name = None + assert datetime_series.index.name is None + assert datetime_series is datetime_series + + cp = datetime_series.copy() + cp.index.name = "foo" + assert datetime_series.index.name is None diff --git a/pandas/tests/series/test_api.py b/pandas/tests/series/test_api.py index c80a2f7cba9ad..c948af41c5e8f 100644 --- a/pandas/tests/series/test_api.py +++ b/pandas/tests/series/test_api.py @@ -1,4 +1,3 @@ -from collections import OrderedDict import pydoc import warnings @@ -25,67 +24,12 @@ import pandas._testing as tm from pandas.core.arrays import PeriodArray -import pandas.io.formats.printing as printing - class TestSeriesMisc: - def test_scalarop_preserve_name(self, datetime_series): - result = datetime_series * 2 - assert result.name == datetime_series.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, datetime_series): - # 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 - - cp = datetime_series.copy() - cp.index.name = "foo" - printing.pprint_thing(datetime_series.index.name) - assert datetime_series.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_binop_maybe_preserve_name(self, datetime_series): - # 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 = datetime_series * datetime_series[:-2] - assert result.name == datetime_series.name - - # names don't match, don't preserve - cp = datetime_series.copy() - cp.name = "something else" - result = datetime_series + cp - assert result.name is None - 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 = datetime_series.copy() - result = getattr(s, op)(s) - assert result.name == datetime_series.name - - # names don't match, don't preserve - cp = datetime_series.copy() - cp.name = "changed" - result = getattr(s, op)(cp) - assert result.name is None - def test_getitem_preserve_name(self, datetime_series): result = datetime_series[datetime_series > 0] assert result.name == datetime_series.name @@ -111,73 +55,6 @@ def _pickle_roundtrip(self, obj): unpickled = pd.read_pickle(path) return unpickled - def test_constructor_dict(self): - d = {"a": 0.0, "b": 1.0, "c": 2.0} - result = Series(d) - expected = Series(d, index=sorted(d.keys())) - tm.assert_series_equal(result, expected) - - result = Series(d, index=["b", "c", "d", "a"]) - expected = Series([1, 2, np.nan, 0], index=["b", "c", "d", "a"]) - tm.assert_series_equal(result, expected) - - def test_constructor_subclass_dict(self, dict_subclass): - data = dict_subclass((x, 10.0 * x) for x in range(10)) - series = Series(data) - expected = Series(dict(data.items())) - tm.assert_series_equal(series, expected) - - def test_constructor_ordereddict(self): - # GH3283 - data = OrderedDict((f"col{i}", np.random.random()) for i in range(12)) - - series = Series(data) - expected = Series(list(data.values()), list(data.keys())) - tm.assert_series_equal(series, expected) - - # Test with subclass - class A(OrderedDict): - pass - - series = Series(A(data)) - tm.assert_series_equal(series, expected) - - def test_constructor_dict_multiindex(self): - d = {("a", "a"): 0.0, ("b", "a"): 1.0, ("b", "c"): 2.0} - _d = sorted(d.items()) - result = Series(d) - expected = Series( - [x[1] for x in _d], index=pd.MultiIndex.from_tuples([x[0] for x in _d]) - ) - tm.assert_series_equal(result, expected) - - d["z"] = 111.0 - _d.insert(0, ("z", d["z"])) - result = Series(d) - expected = Series( - [x[1] for x in _d], index=Index([x[0] for x in _d], tupleize_cols=False) - ) - result = result.reindex(index=expected.index) - tm.assert_series_equal(result, expected) - - def test_constructor_dict_timedelta_index(self): - # GH #12169 : Resample category data with timedelta index - # construct Series from dict as data and TimedeltaIndex as index - # will result NaN in result Series data - expected = Series( - data=["A", "B", "C"], index=pd.to_timedelta([0, 10, 20], unit="s") - ) - - result = Series( - data={ - pd.to_timedelta(0, unit="s"): "A", - pd.to_timedelta(10, unit="s"): "B", - pd.to_timedelta(20, unit="s"): "C", - }, - index=pd.to_timedelta([0, 10, 20], unit="s"), - ) - tm.assert_series_equal(result, expected) - def test_sparse_accessor_updates_on_inplace(self): s = Series([1, 1, 2, 3], dtype="Sparse[int]") return_value = s.drop([0, 1], inplace=True) @@ -324,55 +201,6 @@ def test_raise_on_info(self): with pytest.raises(AttributeError, match=msg): s.info() - def test_copy(self): - - for deep in [None, False, True]: - s = Series(np.arange(10), dtype="float64") - - # default deep is True - if deep is None: - s2 = s.copy() - else: - s2 = s.copy(deep=deep) - - s2[::2] = np.NaN - - if deep is None or deep is True: - # Did not modify original Series - assert np.isnan(s2[0]) - assert not np.isnan(s[0]) - else: - # we DID modify the original Series - assert np.isnan(s2[0]) - assert np.isnan(s[0]) - - def test_copy_tzaware(self): - # GH#11794 - # copy of tz-aware - expected = Series([Timestamp("2012/01/01", tz="UTC")]) - expected2 = Series([Timestamp("1999/01/01", tz="UTC")]) - - for deep in [None, False, True]: - - s = Series([Timestamp("2012/01/01", tz="UTC")]) - - if deep is None: - s2 = s.copy() - else: - s2 = s.copy(deep=deep) - - s2[0] = pd.Timestamp("1999/01/01", tz="UTC") - - # default deep is True - if deep is None or deep is True: - # Did not modify original Series - tm.assert_series_equal(s2, expected2) - tm.assert_series_equal(s, expected) - else: - # we DID modify the original Series - tm.assert_series_equal(s2, expected2) - tm.assert_series_equal(s, expected2) - def test_axis_alias(self): s = Series([1, 2, np.nan]) tm.assert_series_equal(s.dropna(axis="rows"), s.dropna(axis="index")) diff --git a/pandas/tests/series/test_arithmetic.py b/pandas/tests/series/test_arithmetic.py index 00e6fb01da424..ae6a4df8ba699 100644 --- a/pandas/tests/series/test_arithmetic.py +++ b/pandas/tests/series/test_arithmetic.py @@ -741,3 +741,41 @@ def test_series_ops_name_retention(flex, box, names, all_binary_operators): assert result.name == names[2] else: assert result.name == names[0] + + +class TestNamePreservation: + def test_binop_maybe_preserve_name(self, datetime_series): + # 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 = datetime_series * datetime_series[:-2] + assert result.name == datetime_series.name + + # names don't match, don't preserve + cp = datetime_series.copy() + cp.name = "something else" + result = datetime_series + cp + assert result.name is None + 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 + ser = datetime_series.copy() + result = getattr(ser, op)(ser) + assert result.name == datetime_series.name + + # names don't match, don't preserve + cp = datetime_series.copy() + cp.name = "changed" + result = getattr(ser, op)(cp) + assert result.name is None + + def test_scalarop_preserve_name(self, datetime_series): + result = datetime_series * 2 + assert result.name == datetime_series.name diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py index adbdf1077113e..a2fab5c7e0f0e 100644 --- a/pandas/tests/series/test_constructors.py +++ b/pandas/tests/series/test_constructors.py @@ -1062,6 +1062,11 @@ def test_constructor_periodindex(self): def test_constructor_dict(self): d = {"a": 0.0, "b": 1.0, "c": 2.0} + + result = Series(d) + expected = Series(d, index=sorted(d.keys())) + tm.assert_series_equal(result, expected) + result = Series(d, index=["b", "c", "d", "a"]) expected = Series([1, 2, np.nan, 0], index=["b", "c", "d", "a"]) tm.assert_series_equal(result, expected) @@ -1526,6 +1531,63 @@ def test_constructor_list_of_periods_infers_period_dtype(self): ) assert series.dtype == "Period[D]" + def test_constructor_subclass_dict(self, dict_subclass): + data = dict_subclass((x, 10.0 * x) for x in range(10)) + series = Series(data) + expected = Series(dict(data.items())) + tm.assert_series_equal(series, expected) + + def test_constructor_ordereddict(self): + # GH3283 + data = OrderedDict((f"col{i}", np.random.random()) for i in range(12)) + + series = Series(data) + expected = Series(list(data.values()), list(data.keys())) + tm.assert_series_equal(series, expected) + + # Test with subclass + class A(OrderedDict): + pass + + series = Series(A(data)) + tm.assert_series_equal(series, expected) + + def test_constructor_dict_multiindex(self): + d = {("a", "a"): 0.0, ("b", "a"): 1.0, ("b", "c"): 2.0} + _d = sorted(d.items()) + result = Series(d) + expected = Series( + [x[1] for x in _d], index=pd.MultiIndex.from_tuples([x[0] for x in _d]) + ) + tm.assert_series_equal(result, expected) + + d["z"] = 111.0 + _d.insert(0, ("z", d["z"])) + result = Series(d) + expected = Series( + [x[1] for x in _d], index=Index([x[0] for x in _d], tupleize_cols=False) + ) + result = result.reindex(index=expected.index) + tm.assert_series_equal(result, expected) + + def test_constructor_dict_timedelta_index(self): + # GH #12169 : Resample category data with timedelta index + # construct Series from dict as data and TimedeltaIndex as index + # will result NaN in result Series data + expected = Series( + data=["A", "B", "C"], index=pd.to_timedelta([0, 10, 20], unit="s") + ) + + result = Series( + data={ + pd.to_timedelta(0, unit="s"): "A", + pd.to_timedelta(10, unit="s"): "B", + pd.to_timedelta(20, unit="s"): "C", + }, + index=pd.to_timedelta([0, 10, 20], unit="s"), + ) + tm.assert_series_equal(result, expected) + class TestSeriesConstructorIndexCoercion: def test_series_constructor_datetimelike_index_coercion(self):