diff --git a/pandas/tests/frame/test_analytics.py b/pandas/tests/frame/test_analytics.py index baebf414969be..ef68f796a8b02 100644 --- a/pandas/tests/frame/test_analytics.py +++ b/pandas/tests/frame/test_analytics.py @@ -33,44 +33,44 @@ class TestDataFrameAnalytics(TestData): @td.skip_if_no_scipy def test_corr_pearson(self): - self.frame['A'][:5] = nan - self.frame['B'][5:10] = nan + float_frame['A'][:5] = nan + float_frame['B'][5:10] = nan self._check_method('pearson') @td.skip_if_no_scipy def test_corr_kendall(self): - self.frame['A'][:5] = nan - self.frame['B'][5:10] = nan + float_frame['A'][:5] = nan + float_frame['B'][5:10] = nan self._check_method('kendall') @td.skip_if_no_scipy def test_corr_spearman(self): - self.frame['A'][:5] = nan - self.frame['B'][5:10] = nan + float_frame['A'][:5] = nan + float_frame['B'][5:10] = nan self._check_method('spearman') def _check_method(self, method='pearson', check_minp=False): if not check_minp: - correls = self.frame.corr(method=method) - exp = self.frame['A'].corr(self.frame['C'], method=method) + correls = float_frame.corr(method=method) + exp = float_frame['A'].corr(float_frame['C'], method=method) tm.assert_almost_equal(correls['A']['C'], exp) else: - result = self.frame.corr(min_periods=len(self.frame) - 8) - expected = self.frame.corr() + result = float_frame.corr(min_periods=len(float_frame) - 8) + expected = float_frame.corr() expected.loc['A', 'B'] = expected.loc['B', 'A'] = nan tm.assert_frame_equal(result, expected) @td.skip_if_no_scipy def test_corr_non_numeric(self): - self.frame['A'][:5] = nan - self.frame['B'][5:10] = nan + float_frame['A'][:5] = nan + float_frame['B'][5:10] = nan # exclude non-numeric types - result = self.mixed_frame.corr() - expected = self.mixed_frame.loc[:, ['A', 'B', 'C', 'D']].corr() + result = float_string_frame.corr() + expected = float_string_frame.loc[:, ['A', 'B', 'C', 'D']].corr() tm.assert_frame_equal(result, expected) @td.skip_if_no_scipy @@ -140,34 +140,34 @@ def test_corr_invalid_method(self): def test_cov(self): # min_periods no NAs (corner case) - expected = self.frame.cov() - result = self.frame.cov(min_periods=len(self.frame)) + expected = float_frame.cov() + result = float_frame.cov(min_periods=len(float_frame)) tm.assert_frame_equal(expected, result) - result = self.frame.cov(min_periods=len(self.frame) + 1) + result = float_frame.cov(min_periods=len(float_frame) + 1) assert isna(result.values).all() # with NAs - frame = self.frame.copy() + frame = float_frame.copy() frame['A'][:5] = nan frame['B'][5:10] = nan - result = self.frame.cov(min_periods=len(self.frame) - 8) - expected = self.frame.cov() + result = float_frame.cov(min_periods=len(float_frame) - 8) + expected = float_frame.cov() expected.loc['A', 'B'] = np.nan expected.loc['B', 'A'] = np.nan # regular - self.frame['A'][:5] = nan - self.frame['B'][:10] = nan - cov = self.frame.cov() + float_frame['A'][:5] = nan + float_frame['B'][:10] = nan + cov = float_frame.cov() tm.assert_almost_equal(cov['A']['C'], - self.frame['A'].cov(self.frame['C'])) + float_frame['A'].cov(float_frame['C'])) # exclude non-numeric types - result = self.mixed_frame.cov() - expected = self.mixed_frame.loc[:, ['A', 'B', 'C', 'D']].cov() + result = float_string_frame.cov() + expected = float_string_frame.loc[:, ['A', 'B', 'C', 'D']].cov() tm.assert_frame_equal(result, expected) # Single column frame @@ -183,10 +183,10 @@ def test_cov(self): tm.assert_frame_equal(result, expected) def test_corrwith(self): - a = self.tsframe + a = datetime_frame noise = Series(randn(len(a)), index=a.index) - b = self.tsframe.add(noise, axis=0) + b = datetime_frame.add(noise, axis=0) # make sure order does not matter b = b.reindex(columns=b.columns[::-1], index=b.index[::-1][10:]) @@ -232,8 +232,8 @@ def test_corrwith_with_objects(self): tm.assert_series_equal(result, expected) def test_corrwith_series(self): - result = self.tsframe.corrwith(self.tsframe['A']) - expected = self.tsframe.apply(self.tsframe['A'].corr) + result = datetime_frame.corrwith(datetime_frame['A']) + expected = datetime_frame.apply(datetime_frame['A'].corr) tm.assert_series_equal(result, expected) @@ -513,7 +513,7 @@ def test_sum(self): # mixed types (with upcasting happening) self._check_stat_op('sum', np.sum, - frame=self.mixed_float.astype('float32'), + frame=mixed_float_frame.astype('float32'), has_numeric_only=True, check_dtype=False, check_less_precise=True) @@ -563,21 +563,21 @@ def test_min(self): with warnings.catch_warnings(record=True): warnings.simplefilter("ignore", RuntimeWarning) self._check_stat_op('min', np.min, check_dates=True) - self._check_stat_op('min', np.min, frame=self.intframe) + self._check_stat_op('min', np.min, frame=int_frame) def test_cummin(self): - self.tsframe.loc[5:10, 0] = nan - self.tsframe.loc[10:15, 1] = nan - self.tsframe.loc[15:, 2] = nan + datetime_frame.loc[5:10, 0] = nan + datetime_frame.loc[10:15, 1] = nan + datetime_frame.loc[15:, 2] = nan # axis = 0 - cummin = self.tsframe.cummin() - expected = self.tsframe.apply(Series.cummin) + cummin = datetime_frame.cummin() + expected = datetime_frame.apply(Series.cummin) tm.assert_frame_equal(cummin, expected) # axis = 1 - cummin = self.tsframe.cummin(axis=1) - expected = self.tsframe.apply(Series.cummin, axis=1) + cummin = datetime_frame.cummin(axis=1) + expected = datetime_frame.apply(Series.cummin, axis=1) tm.assert_frame_equal(cummin, expected) # it works @@ -585,22 +585,22 @@ def test_cummin(self): result = df.cummin() # noqa # fix issue - cummin_xs = self.tsframe.cummin(axis=1) - assert np.shape(cummin_xs) == np.shape(self.tsframe) + cummin_xs = datetime_frame.cummin(axis=1) + assert np.shape(cummin_xs) == np.shape(datetime_frame) def test_cummax(self): - self.tsframe.loc[5:10, 0] = nan - self.tsframe.loc[10:15, 1] = nan - self.tsframe.loc[15:, 2] = nan + datetime_frame.loc[5:10, 0] = nan + datetime_frame.loc[10:15, 1] = nan + datetime_frame.loc[15:, 2] = nan # axis = 0 - cummax = self.tsframe.cummax() - expected = self.tsframe.apply(Series.cummax) + cummax = datetime_frame.cummax() + expected = datetime_frame.apply(Series.cummax) tm.assert_frame_equal(cummax, expected) # axis = 1 - cummax = self.tsframe.cummax(axis=1) - expected = self.tsframe.apply(Series.cummax, axis=1) + cummax = datetime_frame.cummax(axis=1) + expected = datetime_frame.apply(Series.cummax, axis=1) tm.assert_frame_equal(cummax, expected) # it works @@ -608,14 +608,14 @@ def test_cummax(self): result = df.cummax() # noqa # fix issue - cummax_xs = self.tsframe.cummax(axis=1) - assert np.shape(cummax_xs) == np.shape(self.tsframe) + cummax_xs = datetime_frame.cummax(axis=1) + assert np.shape(cummax_xs) == np.shape(datetime_frame) def test_max(self): with warnings.catch_warnings(record=True): warnings.simplefilter("ignore", RuntimeWarning) self._check_stat_op('max', np.max, check_dates=True) - self._check_stat_op('max', np.max, frame=self.intframe) + self._check_stat_op('max', np.max, frame=int_frame) def test_mad(self): f = lambda x: np.abs(x - x.mean()).mean() @@ -628,12 +628,12 @@ def test_var_std(self): alt = lambda x: np.std(x, ddof=1) self._check_stat_op('std', alt) - result = self.tsframe.std(ddof=4) - expected = self.tsframe.apply(lambda x: x.std(ddof=4)) + result = datetime_frame.std(ddof=4) + expected = datetime_frame.apply(lambda x: x.std(ddof=4)) tm.assert_almost_equal(result, expected) - result = self.tsframe.var(ddof=4) - expected = self.tsframe.apply(lambda x: x.var(ddof=4)) + result = datetime_frame.var(ddof=4) + expected = datetime_frame.apply(lambda x: x.var(ddof=4)) tm.assert_almost_equal(result, expected) arr = np.repeat(np.random.random((1, 1000)), 1000, 0) @@ -686,18 +686,18 @@ def test_mixed_ops(self, op): assert len(result) == 2 def test_cumsum(self): - self.tsframe.loc[5:10, 0] = nan - self.tsframe.loc[10:15, 1] = nan - self.tsframe.loc[15:, 2] = nan + datetime_frame.loc[5:10, 0] = nan + datetime_frame.loc[10:15, 1] = nan + datetime_frame.loc[15:, 2] = nan # axis = 0 - cumsum = self.tsframe.cumsum() - expected = self.tsframe.apply(Series.cumsum) + cumsum = datetime_frame.cumsum() + expected = datetime_frame.apply(Series.cumsum) tm.assert_frame_equal(cumsum, expected) # axis = 1 - cumsum = self.tsframe.cumsum(axis=1) - expected = self.tsframe.apply(Series.cumsum, axis=1) + cumsum = datetime_frame.cumsum(axis=1) + expected = datetime_frame.apply(Series.cumsum, axis=1) tm.assert_frame_equal(cumsum, expected) # works @@ -705,35 +705,35 @@ def test_cumsum(self): result = df.cumsum() # noqa # fix issue - cumsum_xs = self.tsframe.cumsum(axis=1) - assert np.shape(cumsum_xs) == np.shape(self.tsframe) + cumsum_xs = datetime_frame.cumsum(axis=1) + assert np.shape(cumsum_xs) == np.shape(datetime_frame) def test_cumprod(self): - self.tsframe.loc[5:10, 0] = nan - self.tsframe.loc[10:15, 1] = nan - self.tsframe.loc[15:, 2] = nan + datetime_frame.loc[5:10, 0] = nan + datetime_frame.loc[10:15, 1] = nan + datetime_frame.loc[15:, 2] = nan # axis = 0 - cumprod = self.tsframe.cumprod() - expected = self.tsframe.apply(Series.cumprod) + cumprod = datetime_frame.cumprod() + expected = datetime_frame.apply(Series.cumprod) tm.assert_frame_equal(cumprod, expected) # axis = 1 - cumprod = self.tsframe.cumprod(axis=1) - expected = self.tsframe.apply(Series.cumprod, axis=1) + cumprod = datetime_frame.cumprod(axis=1) + expected = datetime_frame.apply(Series.cumprod, axis=1) tm.assert_frame_equal(cumprod, expected) # fix issue - cumprod_xs = self.tsframe.cumprod(axis=1) - assert np.shape(cumprod_xs) == np.shape(self.tsframe) + cumprod_xs = datetime_frame.cumprod(axis=1) + assert np.shape(cumprod_xs) == np.shape(datetime_frame) # ints - df = self.tsframe.fillna(0).astype(int) + df = datetime_frame.fillna(0).astype(int) df.cumprod(0) df.cumprod(1) # ints32 - df = self.tsframe.fillna(0).astype(np.int32) + df = datetime_frame.fillna(0).astype(np.int32) df.cumprod(0) df.cumprod(1) @@ -741,8 +741,8 @@ def test_sem(self): alt = lambda x: np.std(x, ddof=1) / np.sqrt(len(x)) self._check_stat_op('sem', alt) - result = self.tsframe.sem(ddof=4) - expected = self.tsframe.apply( + result = datetime_frame.sem(ddof=4) + expected = datetime_frame.apply( lambda x: x.std(ddof=4) / np.sqrt(len(x))) tm.assert_almost_equal(result, expected) @@ -793,7 +793,7 @@ def _check_stat_op(self, name, alternative, frame=None, has_skipna=True, check_dates=False, check_less_precise=False, skipna_alternative=None): if frame is None: - frame = self.frame + frame = float_frame # set some NAs frame.loc[5:10] = np.nan frame.loc[15:20, -2:] = np.nan @@ -853,18 +853,18 @@ def wrapper(x): # bad axis tm.assert_raises_regex(ValueError, 'No axis named 2', f, axis=2) # make sure works on mixed-type frame - getattr(self.mixed_frame, name)(axis=0) - getattr(self.mixed_frame, name)(axis=1) + getattr(float_string_frame, name)(axis=0) + getattr(float_string_frame, name)(axis=1) if has_numeric_only: - getattr(self.mixed_frame, name)(axis=0, numeric_only=True) - getattr(self.mixed_frame, name)(axis=1, numeric_only=True) - getattr(self.frame, name)(axis=0, numeric_only=False) - getattr(self.frame, name)(axis=1, numeric_only=False) + getattr(float_string_frame, name)(axis=0, numeric_only=True) + getattr(float_string_frame, name)(axis=1, numeric_only=True) + getattr(float_frame, name)(axis=0, numeric_only=False) + getattr(float_frame, name)(axis=1, numeric_only=False) # all NA case if has_skipna: - all_na = self.frame * np.NaN + all_na = float_frame * np.NaN r0 = getattr(all_na, name)(axis=0) r1 = getattr(all_na, name)(axis=1) if name in ['sum', 'prod']: @@ -1023,8 +1023,8 @@ def test_operators_timedelta64(self): assert df['off2'].dtype == 'timedelta64[ns]' def test_sum_corner(self): - axis0 = self.empty.sum(0) - axis1 = self.empty.sum(1) + axis0 = empty_frame.sum(0) + axis1 = empty_frame.sum(1) assert isinstance(axis0, Series) assert isinstance(axis1, Series) assert len(axis0) == 0 @@ -1091,41 +1091,41 @@ def test_sum_nanops_timedelta(self): tm.assert_series_equal(result, expected) def test_sum_object(self): - values = self.frame.values.astype(int) - frame = DataFrame(values, index=self.frame.index, - columns=self.frame.columns) + values = float_frame.values.astype(int) + frame = DataFrame(values, index=float_frame.index, + columns=float_frame.columns) deltas = frame * timedelta(1) deltas.sum() def test_sum_bool(self): # ensure this works, bug report - bools = np.isnan(self.frame) + bools = np.isnan(float_frame) bools.sum(1) bools.sum(0) def test_mean_corner(self): # unit test when have object data - the_mean = self.mixed_frame.mean(axis=0) - the_sum = self.mixed_frame.sum(axis=0, numeric_only=True) + the_mean = float_string_frame.mean(axis=0) + the_sum = float_string_frame.sum(axis=0, numeric_only=True) tm.assert_index_equal(the_sum.index, the_mean.index) - assert len(the_mean.index) < len(self.mixed_frame.columns) + assert len(the_mean.index) < len(float_string_frame.columns) # xs sum mixed type, just want to know it works... - the_mean = self.mixed_frame.mean(axis=1) - the_sum = self.mixed_frame.sum(axis=1, numeric_only=True) + the_mean = float_string_frame.mean(axis=1) + the_sum = float_string_frame.sum(axis=1, numeric_only=True) tm.assert_index_equal(the_sum.index, the_mean.index) # take mean of boolean column - self.frame['bool'] = self.frame['A'] > 0 - means = self.frame.mean(0) - assert means['bool'] == self.frame['bool'].values.mean() + float_frame['bool'] = float_frame['A'] > 0 + means = float_frame.mean(0) + assert means['bool'] == float_frame['bool'].values.mean() def test_stats_mixed_type(self): # don't blow up - self.mixed_frame.std(1) - self.mixed_frame.var(1) - self.mixed_frame.mean(1) - self.mixed_frame.skew(1) + float_string_frame.std(1) + float_string_frame.var(1) + float_string_frame.mean(1) + float_string_frame.skew(1) # TODO: Ensure warning isn't emitted in the first place @pytest.mark.filterwarnings("ignore:All-NaN:RuntimeWarning") @@ -1135,14 +1135,14 @@ def wrapper(x): return np.nan return np.median(x) - self._check_stat_op('median', wrapper, frame=self.intframe, + self._check_stat_op('median', wrapper, frame=int_frame, check_dtype=False, check_dates=True) # Miscellanea def test_count_objects(self): - dm = DataFrame(self.mixed_frame._series) - df = DataFrame(self.mixed_frame._series) + dm = DataFrame(float_string_frame._series) + df = DataFrame(float_string_frame._series) tm.assert_series_equal(dm.count(), df.count()) tm.assert_series_equal(dm.count(1), df.count(1)) @@ -1161,12 +1161,12 @@ def test_sum_bools(self): # Index of max / min def test_idxmin(self): - frame = self.frame + frame = float_frame frame.loc[5:10] = np.nan frame.loc[15:20, -2:] = np.nan for skipna in [True, False]: for axis in [0, 1]: - for df in [frame, self.intframe]: + for df in [frame, int_frame]: result = df.idxmin(axis=axis, skipna=skipna) expected = df.apply(Series.idxmin, axis=axis, skipna=skipna) @@ -1175,12 +1175,12 @@ def test_idxmin(self): pytest.raises(ValueError, frame.idxmin, axis=2) def test_idxmax(self): - frame = self.frame + frame = float_frame frame.loc[5:10] = np.nan frame.loc[15:20, -2:] = np.nan for skipna in [True, False]: for axis in [0, 1]: - for df in [frame, self.intframe]: + for df in [frame, int_frame]: result = df.idxmax(axis=axis, skipna=skipna) expected = df.apply(Series.idxmax, axis=axis, skipna=skipna) @@ -1328,7 +1328,7 @@ def test_any_all_level_axis_none_raises(self, method): def _check_bool_op(self, name, alternative, frame=None, has_skipna=True, has_bool_only=False): if frame is None: - frame = self.frame > 0 + frame = float_frame > 0 # set some NAs frame = DataFrame(frame.values.astype(object), frame.index, frame.columns) @@ -1368,7 +1368,7 @@ def wrapper(x): pytest.raises(ValueError, f, axis=2) # make sure works on mixed-type frame - mixed = self.mixed_frame + mixed = float_string_frame mixed['_bool_'] = np.random.randn(len(mixed)) > 0 getattr(mixed, name)(axis=0) getattr(mixed, name)(axis=1) @@ -1747,33 +1747,33 @@ def test_pct_change(self): # Clip def test_clip(self): - median = self.frame.median().median() - original = self.frame.copy() + median = float_frame.median().median() + original = float_frame.copy() - capped = self.frame.clip_upper(median) + capped = float_frame.clip_upper(median) assert not (capped.values > median).any() - floored = self.frame.clip_lower(median) + floored = float_frame.clip_lower(median) assert not (floored.values < median).any() - double = self.frame.clip(upper=median, lower=median) + double = float_frame.clip(upper=median, lower=median) assert not (double.values != median).any() - # Verify that self.frame was not changed inplace - assert (self.frame.values == original.values).all() + # Verify that float_frame was not changed inplace + assert (float_frame.values == original.values).all() def test_inplace_clip(self): # GH #15388 - median = self.frame.median().median() - frame_copy = self.frame.copy() + median = float_frame.median().median() + frame_copy = float_frame.copy() frame_copy.clip_upper(median, inplace=True) assert not (frame_copy.values > median).any() - frame_copy = self.frame.copy() + frame_copy = float_frame.copy() frame_copy.clip_lower(median, inplace=True) assert not (frame_copy.values < median).any() - frame_copy = self.frame.copy() + frame_copy = float_frame.copy() frame_copy.clip(upper=median, lower=median, inplace=True) assert not (frame_copy.values != median).any() @@ -1841,7 +1841,7 @@ def test_clip_against_series(self, inplace): ]) def test_clip_against_list_like(self, inplace, lower, axis, res): # GH #15390 - original = self.simple.copy(deep=True) + original = simple_frame.copy(deep=True) result = original.clip(lower=lower, upper=[5, 6, 7], axis=axis, inplace=inplace) @@ -1872,9 +1872,9 @@ def test_clip_against_frame(self, axis): def test_clip_with_na_args(self): """Should process np.nan argument as None """ # GH # 17276 - tm.assert_frame_equal(self.frame.clip(np.nan), self.frame) - tm.assert_frame_equal(self.frame.clip(upper=np.nan, lower=np.nan), - self.frame) + tm.assert_frame_equal(float_frame.clip(np.nan), float_frame) + tm.assert_frame_equal(float_frame.clip(upper=np.nan, lower=np.nan), + float_frame) # GH #19992 df = DataFrame({'col_0': [1, 2, 3], 'col_1': [4, 5, 6], diff --git a/pandas/tests/frame/test_axis_select_reindex.py b/pandas/tests/frame/test_axis_select_reindex.py index 0bc74c6890ee9..dbb9aff2a900e 100644 --- a/pandas/tests/frame/test_axis_select_reindex.py +++ b/pandas/tests/frame/test_axis_select_reindex.py @@ -207,33 +207,33 @@ def test_merge_join_different_levels(self): tm.assert_frame_equal(result, expected) def test_reindex(self): - newFrame = self.frame.reindex(self.ts1.index) + newFrame = float_frame.reindex(datetime_series.index) for col in newFrame.columns: for idx, val in compat.iteritems(newFrame[col]): - if idx in self.frame.index: + if idx in float_frame.index: if np.isnan(val): - assert np.isnan(self.frame[col][idx]) + assert np.isnan(float_frame[col][idx]) else: - assert val == self.frame[col][idx] + assert val == float_frame[col][idx] else: assert np.isnan(val) for col, series in compat.iteritems(newFrame): assert tm.equalContents(series.index, newFrame.index) - emptyFrame = self.frame.reindex(Index([])) + emptyFrame = float_frame.reindex(Index([])) assert len(emptyFrame.index) == 0 # Cython code should be unit-tested directly - nonContigFrame = self.frame.reindex(self.ts1.index[::2]) + nonContigFrame = float_frame.reindex(datetime_series.index[::2]) for col in nonContigFrame.columns: for idx, val in compat.iteritems(nonContigFrame[col]): - if idx in self.frame.index: + if idx in float_frame.index: if np.isnan(val): - assert np.isnan(self.frame[col][idx]) + assert np.isnan(float_frame[col][idx]) else: - assert val == self.frame[col][idx] + assert val == float_frame[col][idx] else: assert np.isnan(val) @@ -243,28 +243,28 @@ def test_reindex(self): # corner cases # Same index, copies values but not index if copy=False - newFrame = self.frame.reindex(self.frame.index, copy=False) - assert newFrame.index is self.frame.index + newFrame = float_frame.reindex(float_frame.index, copy=False) + assert newFrame.index is float_frame.index # length zero - newFrame = self.frame.reindex([]) + newFrame = float_frame.reindex([]) assert newFrame.empty - assert len(newFrame.columns) == len(self.frame.columns) + assert len(newFrame.columns) == len(float_frame.columns) # length zero with columns reindexed with non-empty index - newFrame = self.frame.reindex([]) - newFrame = newFrame.reindex(self.frame.index) - assert len(newFrame.index) == len(self.frame.index) - assert len(newFrame.columns) == len(self.frame.columns) + newFrame = float_frame.reindex([]) + newFrame = newFrame.reindex(float_frame.index) + assert len(newFrame.index) == len(float_frame.index) + assert len(newFrame.columns) == len(float_frame.columns) # pass non-Index - newFrame = self.frame.reindex(list(self.ts1.index)) - tm.assert_index_equal(newFrame.index, self.ts1.index) + newFrame = float_frame.reindex(list(datetime_series.index)) + tm.assert_index_equal(newFrame.index, datetime_series.index) # copy with no axes - result = self.frame.reindex() - assert_frame_equal(result, self.frame) - assert result is not self.frame + result = float_frame.reindex() + assert_frame_equal(result, float_frame) + assert result is not float_frame def test_reindex_nan(self): df = pd.DataFrame([[1, 2], [3, 5], [7, 11], [9, 23]], @@ -308,31 +308,31 @@ def test_reindex_name_remains(self): assert df.columns.name == 'iname' def test_reindex_int(self): - smaller = self.intframe.reindex(self.intframe.index[::2]) + smaller = int_frame.reindex(int_frame.index[::2]) assert smaller['A'].dtype == np.int64 - bigger = smaller.reindex(self.intframe.index) + bigger = smaller.reindex(int_frame.index) assert bigger['A'].dtype == np.float64 - smaller = self.intframe.reindex(columns=['A', 'B']) + smaller = int_frame.reindex(columns=['A', 'B']) assert smaller['A'].dtype == np.int64 def test_reindex_like(self): - other = self.frame.reindex(index=self.frame.index[:10], + other = float_frame.reindex(index=float_frame.index[:10], columns=['C', 'B']) - assert_frame_equal(other, self.frame.reindex_like(other)) + assert_frame_equal(other, float_frame.reindex_like(other)) def test_reindex_columns(self): - new_frame = self.frame.reindex(columns=['A', 'B', 'E']) + new_frame = float_frame.reindex(columns=['A', 'B', 'E']) - tm.assert_series_equal(new_frame['B'], self.frame['B']) + tm.assert_series_equal(new_frame['B'], float_frame['B']) assert np.isnan(new_frame['E']).all() assert 'C' not in new_frame # Length zero - new_frame = self.frame.reindex(columns=[]) + new_frame = float_frame.reindex(columns=[]) assert new_frame.empty def test_reindex_columns_method(self): @@ -546,40 +546,40 @@ def test_reindex_api_equivalence(self): tm.assert_frame_equal(res1, res) def test_align(self): - af, bf = self.frame.align(self.frame) - assert af._data is not self.frame._data + af, bf = float_frame.align(float_frame) + assert af._data is not float_frame._data - af, bf = self.frame.align(self.frame, copy=False) - assert af._data is self.frame._data + af, bf = float_frame.align(float_frame, copy=False) + assert af._data is float_frame._data # axis = 0 - other = self.frame.iloc[:-5, :3] - af, bf = self.frame.align(other, axis=0, fill_value=-1) + other = float_frame.iloc[:-5, :3] + af, bf = float_frame.align(other, axis=0, fill_value=-1) tm.assert_index_equal(bf.columns, other.columns) # test fill value - join_idx = self.frame.index.join(other.index) - diff_a = self.frame.index.difference(join_idx) + join_idx = float_frame.index.join(other.index) + diff_a = float_frame.index.difference(join_idx) diff_b = other.index.difference(join_idx) diff_a_vals = af.reindex(diff_a).values diff_b_vals = bf.reindex(diff_b).values assert (diff_a_vals == -1).all() - af, bf = self.frame.align(other, join='right', axis=0) + af, bf = float_frame.align(other, join='right', axis=0) tm.assert_index_equal(bf.columns, other.columns) tm.assert_index_equal(bf.index, other.index) tm.assert_index_equal(af.index, other.index) # axis = 1 - other = self.frame.iloc[:-5, :3].copy() - af, bf = self.frame.align(other, axis=1) - tm.assert_index_equal(bf.columns, self.frame.columns) + other = float_frame.iloc[:-5, :3].copy() + af, bf = float_frame.align(other, axis=1) + tm.assert_index_equal(bf.columns, float_frame.columns) tm.assert_index_equal(bf.index, other.index) # test fill value - join_idx = self.frame.index.join(other.index) - diff_a = self.frame.index.difference(join_idx) + join_idx = float_frame.index.join(other.index) + diff_a = float_frame.index.difference(join_idx) diff_b = other.index.difference(join_idx) diff_a_vals = af.reindex(diff_a).values @@ -588,57 +588,57 @@ def test_align(self): assert (diff_a_vals == -1).all() - af, bf = self.frame.align(other, join='inner', axis=1) + af, bf = float_frame.align(other, join='inner', axis=1) tm.assert_index_equal(bf.columns, other.columns) - af, bf = self.frame.align(other, join='inner', axis=1, method='pad') + af, bf = float_frame.align(other, join='inner', axis=1, method='pad') tm.assert_index_equal(bf.columns, other.columns) # test other non-float types - af, bf = self.intframe.align(other, join='inner', axis=1, method='pad') + af, bf = int_frame.align(other, join='inner', axis=1, method='pad') tm.assert_index_equal(bf.columns, other.columns) - af, bf = self.mixed_frame.align(self.mixed_frame, + af, bf = float_string_frame.align(float_string_frame, join='inner', axis=1, method='pad') - tm.assert_index_equal(bf.columns, self.mixed_frame.columns) + tm.assert_index_equal(bf.columns, float_string_frame.columns) - af, bf = self.frame.align(other.iloc[:, 0], join='inner', axis=1, + af, bf = float_frame.align(other.iloc[:, 0], join='inner', axis=1, method=None, fill_value=None) tm.assert_index_equal(bf.index, Index([])) - af, bf = self.frame.align(other.iloc[:, 0], join='inner', axis=1, + af, bf = float_frame.align(other.iloc[:, 0], join='inner', axis=1, method=None, fill_value=0) tm.assert_index_equal(bf.index, Index([])) # mixed floats/ints - af, bf = self.mixed_float.align(other.iloc[:, 0], join='inner', axis=1, + af, bf = mixed_float_frame.align(other.iloc[:, 0], join='inner', axis=1, method=None, fill_value=0) tm.assert_index_equal(bf.index, Index([])) - af, bf = self.mixed_int.align(other.iloc[:, 0], join='inner', axis=1, + af, bf = mixed_int_frame.align(other.iloc[:, 0], join='inner', axis=1, method=None, fill_value=0) tm.assert_index_equal(bf.index, Index([])) # Try to align DataFrame to Series along bad axis with pytest.raises(ValueError): - self.frame.align(af.iloc[0, :3], join='inner', axis=2) + float_frame.align(af.iloc[0, :3], join='inner', axis=2) # align dataframe to series with broadcast or not - idx = self.frame.index + idx = float_frame.index s = Series(range(len(idx)), index=idx) - left, right = self.frame.align(s, axis=0) - tm.assert_index_equal(left.index, self.frame.index) - tm.assert_index_equal(right.index, self.frame.index) + left, right = float_frame.align(s, axis=0) + tm.assert_index_equal(left.index, float_frame.index) + tm.assert_index_equal(right.index, float_frame.index) assert isinstance(right, Series) - left, right = self.frame.align(s, broadcast_axis=1) - tm.assert_index_equal(left.index, self.frame.index) + left, right = float_frame.align(s, broadcast_axis=1) + tm.assert_index_equal(left.index, float_frame.index) expected = {} - for c in self.frame.columns: + for c in float_frame.columns: expected[c] = s - expected = DataFrame(expected, index=self.frame.index, - columns=self.frame.columns) + expected = DataFrame(expected, index=float_frame.index, + columns=float_frame.columns) tm.assert_frame_equal(right, expected) # see gh-9558 @@ -682,9 +682,9 @@ def test_align_fill_method(self, how, meth, ax, fax): self._check_align_fill(how, meth, ax, fax) def _check_align_fill(self, kind, meth, ax, fax): - left = self.frame.iloc[0:4, :10] - right = self.frame.iloc[2:, 6:] - empty = self.frame.iloc[:0, :0] + left = float_frame.iloc[0:4, :10] + right = float_frame.iloc[2:, 6:] + empty = float_frame.iloc[:0, :0] self._check_align(left, right, axis=ax, fill_axis=fax, how=kind, method=meth) @@ -779,22 +779,22 @@ def test_align_series_combinations(self): def test_filter(self): # Items - filtered = self.frame.filter(['A', 'B', 'E']) + filtered = float_frame.filter(['A', 'B', 'E']) assert len(filtered.columns) == 2 assert 'E' not in filtered - filtered = self.frame.filter(['A', 'B', 'E'], axis='columns') + filtered = float_frame.filter(['A', 'B', 'E'], axis='columns') assert len(filtered.columns) == 2 assert 'E' not in filtered # Other axis - idx = self.frame.index[0:4] - filtered = self.frame.filter(idx, axis='index') - expected = self.frame.reindex(index=idx) + idx = float_frame.index[0:4] + filtered = float_frame.filter(idx, axis='index') + expected = float_frame.reindex(index=idx) tm.assert_frame_equal(filtered, expected) # like - fcopy = self.frame.copy() + fcopy = float_frame.copy() fcopy['AA'] = 1 filtered = fcopy.filter(like='A') @@ -821,35 +821,35 @@ def test_filter(self): # pass in None with tm.assert_raises_regex(TypeError, 'Must pass'): - self.frame.filter() + float_frame.filter() with tm.assert_raises_regex(TypeError, 'Must pass'): - self.frame.filter(items=None) + float_frame.filter(items=None) with tm.assert_raises_regex(TypeError, 'Must pass'): - self.frame.filter(axis=1) + float_frame.filter(axis=1) # test mutually exclusive arguments with tm.assert_raises_regex(TypeError, 'mutually exclusive'): - self.frame.filter(items=['one', 'three'], regex='e$', like='bbi') + float_frame.filter(items=['one', 'three'], regex='e$', like='bbi') with tm.assert_raises_regex(TypeError, 'mutually exclusive'): - self.frame.filter(items=['one', 'three'], regex='e$', axis=1) + float_frame.filter(items=['one', 'three'], regex='e$', axis=1) with tm.assert_raises_regex(TypeError, 'mutually exclusive'): - self.frame.filter(items=['one', 'three'], regex='e$') + float_frame.filter(items=['one', 'three'], regex='e$') with tm.assert_raises_regex(TypeError, 'mutually exclusive'): - self.frame.filter(items=['one', 'three'], like='bbi', axis=0) + float_frame.filter(items=['one', 'three'], like='bbi', axis=0) with tm.assert_raises_regex(TypeError, 'mutually exclusive'): - self.frame.filter(items=['one', 'three'], like='bbi') + float_frame.filter(items=['one', 'three'], like='bbi') # objects - filtered = self.mixed_frame.filter(like='foo') + filtered = float_string_frame.filter(like='foo') assert 'foo' in filtered # unicode columns, won't ascii-encode - df = self.frame.rename(columns={'B': u('\u2202')}) + df = float_frame.rename(columns={'B': u('\u2202')}) filtered = df.filter(like='C') assert 'C' in filtered def test_filter_regex_search(self): - fcopy = self.frame.copy() + fcopy = float_frame.copy() fcopy['AA'] = 1 # regex @@ -901,26 +901,26 @@ def test_select(self): # deprecated: gh-12410 f = lambda x: x.weekday() == 2 - index = self.tsframe.index[[f(x) for x in self.tsframe.index]] - expected_weekdays = self.tsframe.reindex(index=index) + index = datetime_frame.index[[f(x) for x in datetime_frame.index]] + expected_weekdays = datetime_frame.reindex(index=index) with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): - result = self.tsframe.select(f, axis=0) + result = datetime_frame.select(f, axis=0) assert_frame_equal(result, expected_weekdays) - result = self.frame.select(lambda x: x in ('B', 'D'), axis=1) - expected = self.frame.reindex(columns=['B', 'D']) + result = float_frame.select(lambda x: x in ('B', 'D'), axis=1) + expected = float_frame.reindex(columns=['B', 'D']) assert_frame_equal(result, expected, check_names=False) # replacement f = lambda x: x.weekday == 2 - result = self.tsframe.loc(axis=0)[f(self.tsframe.index)] + result = datetime_frame.loc(axis=0)[f(datetime_frame.index)] assert_frame_equal(result, expected_weekdays) crit = lambda x: x in ['B', 'D'] - result = self.frame.loc(axis=1)[(self.frame.columns.map(crit))] - expected = self.frame.reindex(columns=['B', 'D']) + result = float_frame.loc(axis=1)[(float_frame.columns.map(crit))] + expected = float_frame.reindex(columns=['B', 'D']) assert_frame_equal(result, expected, check_names=False) # doc example @@ -935,7 +935,7 @@ def test_select(self): def test_take(self): # homogeneous order = [3, 1, 2, 0] - for df in [self.frame]: + for df in [float_frame]: result = df.take(order, axis=0) expected = df.reindex(df.index.take(order)) @@ -948,7 +948,7 @@ def test_take(self): # negative indices order = [2, 1, -1] - for df in [self.frame]: + for df in [float_frame]: result = df.take(order, axis=0) expected = df.reindex(df.index.take(order)) @@ -975,7 +975,7 @@ def test_take(self): # mixed-dtype order = [4, 1, 2, 0, 3] - for df in [self.mixed_frame]: + for df in [float_string_frame]: result = df.take(order, axis=0) expected = df.reindex(df.index.take(order)) @@ -988,7 +988,7 @@ def test_take(self): # negative indices order = [4, 1, -2] - for df in [self.mixed_frame]: + for df in [float_string_frame]: result = df.take(order, axis=0) expected = df.reindex(df.index.take(order)) @@ -1001,7 +1001,7 @@ def test_take(self): # by dtype order = [1, 2, 0, 3] - for df in [self.mixed_float, self.mixed_int]: + for df in [mixed_float_frame, mixed_int_frame]: result = df.take(order, axis=0) expected = df.reindex(df.index.take(order)) @@ -1026,45 +1026,45 @@ def test_reindex_boolean(self): assert isna(reindexed[1]).all() def test_reindex_objects(self): - reindexed = self.mixed_frame.reindex(columns=['foo', 'A', 'B']) + reindexed = float_string_frame.reindex(columns=['foo', 'A', 'B']) assert 'foo' in reindexed - reindexed = self.mixed_frame.reindex(columns=['A', 'B']) + reindexed = float_string_frame.reindex(columns=['A', 'B']) assert 'foo' not in reindexed def test_reindex_corner(self): index = Index(['a', 'b', 'c']) - dm = self.empty.reindex(index=[1, 2, 3]) + dm = empty_frame.reindex(index=[1, 2, 3]) reindexed = dm.reindex(columns=index) tm.assert_index_equal(reindexed.columns, index) # ints are weird - smaller = self.intframe.reindex(columns=['A', 'B', 'E']) + smaller = int_frame.reindex(columns=['A', 'B', 'E']) assert smaller['E'].dtype == np.float64 def test_reindex_axis(self): cols = ['A', 'B', 'E'] with tm.assert_produces_warning(FutureWarning) as m: - reindexed1 = self.intframe.reindex_axis(cols, axis=1) + reindexed1 = int_frame.reindex_axis(cols, axis=1) assert 'reindex' in str(m[0].message) - reindexed2 = self.intframe.reindex(columns=cols) + reindexed2 = int_frame.reindex(columns=cols) assert_frame_equal(reindexed1, reindexed2) - rows = self.intframe.index[0:5] + rows = int_frame.index[0:5] with tm.assert_produces_warning(FutureWarning) as m: - reindexed1 = self.intframe.reindex_axis(rows, axis=0) + reindexed1 = int_frame.reindex_axis(rows, axis=0) assert 'reindex' in str(m[0].message) - reindexed2 = self.intframe.reindex(index=rows) + reindexed2 = int_frame.reindex(index=rows) assert_frame_equal(reindexed1, reindexed2) - pytest.raises(ValueError, self.intframe.reindex_axis, rows, axis=2) + pytest.raises(ValueError, int_frame.reindex_axis, rows, axis=2) # no-op case - cols = self.frame.columns.copy() + cols = float_frame.columns.copy() with tm.assert_produces_warning(FutureWarning) as m: - newFrame = self.frame.reindex_axis(cols, axis=1) + newFrame = float_frame.reindex_axis(cols, axis=1) assert 'reindex' in str(m[0].message) - assert_frame_equal(newFrame, self.frame) + assert_frame_equal(newFrame, float_frame) def test_reindex_with_nans(self): df = DataFrame([[1, 2], [3, 4], [np.nan, np.nan], [7, 8], [9, 10]], diff --git a/pandas/tests/frame/test_block_internals.py b/pandas/tests/frame/test_block_internals.py index 3fe1c84174acb..c21c1575ab667 100644 --- a/pandas/tests/frame/test_block_internals.py +++ b/pandas/tests/frame/test_block_internals.py @@ -32,17 +32,17 @@ class TestDataFrameBlockInternals(TestData): def test_cast_internals(self): - casted = DataFrame(self.frame._data, dtype=int) - expected = DataFrame(self.frame._series, dtype=int) + casted = DataFrame(float_frame._data, dtype=int) + expected = DataFrame(float_frame._series, dtype=int) assert_frame_equal(casted, expected) - casted = DataFrame(self.frame._data, dtype=np.int32) - expected = DataFrame(self.frame._series, dtype=np.int32) + casted = DataFrame(float_frame._data, dtype=np.int32) + expected = DataFrame(float_frame._series, dtype=np.int32) assert_frame_equal(casted, expected) def test_consolidate(self): - self.frame['E'] = 7. - consolidated = self.frame._consolidate() + float_frame['E'] = 7. + consolidated = float_frame._consolidate() assert len(consolidated._data.blocks) == 1 # Ensure copy, do I want this? @@ -50,92 +50,92 @@ def test_consolidate(self): assert recons is not consolidated tm.assert_frame_equal(recons, consolidated) - self.frame['F'] = 8. - assert len(self.frame._data.blocks) == 3 + float_frame['F'] = 8. + assert len(float_frame._data.blocks) == 3 - self.frame._consolidate(inplace=True) - assert len(self.frame._data.blocks) == 1 + float_frame._consolidate(inplace=True) + assert len(float_frame._data.blocks) == 1 def test_consolidate_deprecation(self): - self.frame['E'] = 7 + float_frame['E'] = 7 with tm.assert_produces_warning(FutureWarning): - self.frame.consolidate() + float_frame.consolidate() def test_consolidate_inplace(self): - frame = self.frame.copy() # noqa + frame = float_frame.copy() # noqa # triggers in-place consolidation for letter in range(ord('A'), ord('Z')): - self.frame[chr(letter)] = chr(letter) + float_frame[chr(letter)] = chr(letter) def test_values_consolidate(self): - self.frame['E'] = 7. - assert not self.frame._data.is_consolidated() - _ = self.frame.values # noqa - assert self.frame._data.is_consolidated() + float_frame['E'] = 7. + assert not float_frame._data.is_consolidated() + _ = float_frame.values # noqa + assert float_frame._data.is_consolidated() def test_modify_values(self): - self.frame.values[5] = 5 - assert (self.frame.values[5] == 5).all() + float_frame.values[5] = 5 + assert (float_frame.values[5] == 5).all() # unconsolidated - self.frame['E'] = 7. - self.frame.values[6] = 6 - assert (self.frame.values[6] == 6).all() + float_frame['E'] = 7. + float_frame.values[6] = 6 + assert (float_frame.values[6] == 6).all() def test_boolean_set_uncons(self): - self.frame['E'] = 7. + float_frame['E'] = 7. - expected = self.frame.values.copy() + expected = float_frame.values.copy() expected[expected > 1] = 2 - self.frame[self.frame > 1] = 2 - assert_almost_equal(expected, self.frame.values) + float_frame[float_frame > 1] = 2 + assert_almost_equal(expected, float_frame.values) def test_values_numeric_cols(self): - self.frame['foo'] = 'bar' + float_frame['foo'] = 'bar' - values = self.frame[['A', 'B', 'C', 'D']].values + values = float_frame[['A', 'B', 'C', 'D']].values assert values.dtype == np.float64 def test_values_lcd(self): # mixed lcd - values = self.mixed_float[['A', 'B', 'C', 'D']].values + values = mixed_float_frame[['A', 'B', 'C', 'D']].values assert values.dtype == np.float64 - values = self.mixed_float[['A', 'B', 'C']].values + values = mixed_float_frame[['A', 'B', 'C']].values assert values.dtype == np.float32 - values = self.mixed_float[['C']].values + values = mixed_float_frame[['C']].values assert values.dtype == np.float16 # GH 10364 # B uint64 forces float because there are other signed int types - values = self.mixed_int[['A', 'B', 'C', 'D']].values + values = mixed_int_frame[['A', 'B', 'C', 'D']].values assert values.dtype == np.float64 - values = self.mixed_int[['A', 'D']].values + values = mixed_int_frame[['A', 'D']].values assert values.dtype == np.int64 # B uint64 forces float because there are other signed int types - values = self.mixed_int[['A', 'B', 'C']].values + values = mixed_int_frame[['A', 'B', 'C']].values assert values.dtype == np.float64 # as B and C are both unsigned, no forcing to float is needed - values = self.mixed_int[['B', 'C']].values + values = mixed_int_frame[['B', 'C']].values assert values.dtype == np.uint64 - values = self.mixed_int[['A', 'C']].values + values = mixed_int_frame[['A', 'C']].values assert values.dtype == np.int32 - values = self.mixed_int[['C', 'D']].values + values = mixed_int_frame[['C', 'D']].values assert values.dtype == np.int64 - values = self.mixed_int[['A']].values + values = mixed_int_frame[['A']].values assert values.dtype == np.int32 - values = self.mixed_int[['C']].values + values = mixed_int_frame[['C']].values assert values.dtype == np.uint8 def test_constructor_with_convert(self): @@ -219,11 +219,11 @@ def test_construction_with_mixed(self): expected = Series({'datetime64[ns]': 3}) # mixed-type frames - self.mixed_frame['datetime'] = datetime.now() - self.mixed_frame['timedelta'] = timedelta(days=1, seconds=1) - assert self.mixed_frame['datetime'].dtype == 'M8[ns]' - assert self.mixed_frame['timedelta'].dtype == 'm8[ns]' - result = self.mixed_frame.get_dtype_counts().sort_values() + float_string_frame['datetime'] = datetime.now() + float_string_frame['timedelta'] = timedelta(days=1, seconds=1) + assert float_string_frame['datetime'].dtype == 'M8[ns]' + assert float_string_frame['timedelta'].dtype == 'm8[ns]' + result = float_string_frame.get_dtype_counts().sort_values() expected = Series({'float64': 4, 'object': 1, 'datetime64[ns]': 1, @@ -298,7 +298,7 @@ def test_equals_different_blocks(self): def test_copy_blocks(self): # API/ENH 9607 - df = DataFrame(self.frame, copy=True) + df = DataFrame(float_frame, copy=True) column = df.columns[0] # use the default copy=True, change a column @@ -316,7 +316,7 @@ def test_copy_blocks(self): def test_no_copy_blocks(self): # API/ENH 9607 - df = DataFrame(self.frame, copy=True) + df = DataFrame(float_frame, copy=True) column = df.columns[0] # use the copy=False, change a column @@ -333,28 +333,28 @@ def test_no_copy_blocks(self): assert _df[column].equals(df[column]) def test_copy(self): - cop = self.frame.copy() + cop = float_frame.copy() cop['E'] = cop['A'] - assert 'E' not in self.frame + assert 'E' not in float_frame # copy objects - copy = self.mixed_frame.copy() - assert copy._data is not self.mixed_frame._data + copy = float_string_frame.copy() + assert copy._data is not float_string_frame._data def test_pickle(self): - unpickled = tm.round_trip_pickle(self.mixed_frame) - assert_frame_equal(self.mixed_frame, unpickled) + unpickled = tm.round_trip_pickle(float_string_frame) + assert_frame_equal(float_string_frame, unpickled) # buglet - self.mixed_frame._data.ndim + float_string_frame._data.ndim # empty - unpickled = tm.round_trip_pickle(self.empty) + unpickled = tm.round_trip_pickle(empty_frame) repr(unpickled) # tz frame - unpickled = tm.round_trip_pickle(self.tzframe) - assert_frame_equal(self.tzframe, unpickled) + unpickled = tm.round_trip_pickle(timezone_frame) + assert_frame_equal(timezone_frame, unpickled) def test_consolidate_datetime64(self): # numpy vstack bug @@ -389,8 +389,8 @@ def test_consolidate_datetime64(self): tm.assert_index_equal(pd.DatetimeIndex(df.ending), ser_ending.index) def test_is_mixed_type(self): - assert not self.frame._is_mixed_type - assert self.mixed_frame._is_mixed_type + assert not float_frame._is_mixed_type + assert float_string_frame._is_mixed_type def test_get_numeric_data(self): # TODO(wesm): unused? @@ -450,21 +450,21 @@ def test_get_numeric_data_extension_dtype(self): def test_convert_objects(self): - oops = self.mixed_frame.T.T + oops = float_string_frame.T.T converted = oops._convert(datetime=True) - assert_frame_equal(converted, self.mixed_frame) + assert_frame_equal(converted, float_string_frame) assert converted['A'].dtype == np.float64 # force numeric conversion - self.mixed_frame['H'] = '1.' - self.mixed_frame['I'] = '1' + float_string_frame['H'] = '1.' + float_string_frame['I'] = '1' # add in some items that will be nan - length = len(self.mixed_frame) - self.mixed_frame['J'] = '1.' - self.mixed_frame['K'] = '1' - self.mixed_frame.loc[0:5, ['J', 'K']] = 'garbled' - converted = self.mixed_frame._convert(datetime=True, numeric=True) + length = len(float_string_frame) + float_string_frame['J'] = '1.' + float_string_frame['K'] = '1' + float_string_frame.loc[0:5, ['J', 'K']] = 'garbled' + converted = float_string_frame._convert(datetime=True, numeric=True) assert converted['H'].dtype == 'float64' assert converted['I'].dtype == 'int64' assert converted['J'].dtype == 'float64' @@ -473,14 +473,14 @@ def test_convert_objects(self): assert len(converted['K'].dropna()) == length - 5 # via astype - converted = self.mixed_frame.copy() + converted = float_string_frame.copy() converted['H'] = converted['H'].astype('float64') converted['I'] = converted['I'].astype('int64') assert converted['H'].dtype == 'float64' assert converted['I'].dtype == 'int64' # via astype, but errors - converted = self.mixed_frame.copy() + converted = float_string_frame.copy() with tm.assert_raises_regex(ValueError, 'invalid literal'): converted['H'].astype('int32') diff --git a/pandas/tests/frame/test_combine_concat.py b/pandas/tests/frame/test_combine_concat.py index 15ca65395e4fc..c92f1da158ab4 100644 --- a/pandas/tests/frame/test_combine_concat.py +++ b/pandas/tests/frame/test_combine_concat.py @@ -459,20 +459,20 @@ def test_combine_first_mixed(self): def test_combine_first(self): # disjoint - head, tail = self.frame[:5], self.frame[5:] + head, tail = float_frame[:5], float_frame[5:] combined = head.combine_first(tail) - reordered_frame = self.frame.reindex(combined.index) + reordered_frame = float_frame.reindex(combined.index) assert_frame_equal(combined, reordered_frame) - assert tm.equalContents(combined.columns, self.frame.columns) + assert tm.equalContents(combined.columns, float_frame.columns) assert_series_equal(combined['A'], reordered_frame['A']) # same index - fcopy = self.frame.copy() + fcopy = float_frame.copy() fcopy['A'] = 1 del fcopy['C'] - fcopy2 = self.frame.copy() + fcopy2 = float_frame.copy() fcopy2['B'] = 0 del fcopy2['D'] @@ -496,20 +496,20 @@ def test_combine_first(self): assert (combined['A'][:10] == 0).all() # no overlap - f = self.frame[:10] - g = self.frame[10:] + f = float_frame[:10] + g = float_frame[10:] combined = f.combine_first(g) assert_series_equal(combined['A'].reindex(f.index), f['A']) assert_series_equal(combined['A'].reindex(g.index), g['A']) # corner cases - comb = self.frame.combine_first(self.empty) - assert_frame_equal(comb, self.frame) + comb = float_frame.combine_first(empty_frame) + assert_frame_equal(comb, float_frame) - comb = self.empty.combine_first(self.frame) - assert_frame_equal(comb, self.frame) + comb = empty_frame.combine_first(float_frame) + assert_frame_equal(comb, float_frame) - comb = self.frame.combine_first(DataFrame(index=["faz", "boo"])) + comb = float_frame.combine_first(DataFrame(index=["faz", "boo"])) assert "faz" in comb.index # #2525 diff --git a/pandas/tests/frame/test_constructors.py b/pandas/tests/frame/test_constructors.py index 2f1c9e05a01b0..f3fbb4d1aea70 100644 --- a/pandas/tests/frame/test_constructors.py +++ b/pandas/tests/frame/test_constructors.py @@ -48,7 +48,7 @@ def test_constructor_mixed(self): indexed_frame = DataFrame(data, index=index) # noqa unindexed_frame = DataFrame(data) # noqa - assert self.mixed_frame['foo'].dtype == np.object_ + assert float_string_frame['foo'].dtype == np.object_ def test_constructor_cast_failure(self): foo = DataFrame({'a': ['a', 'b', 'c']}, dtype=np.float64) @@ -163,12 +163,12 @@ def test_constructor_dtype_str_na_values(self, string_dtype): assert np.isnan(df.iloc[1, 0]) def test_constructor_rec(self): - rec = self.frame.to_records(index=False) + rec = float_frame.to_records(index=False) # Assigning causes segfault in NumPy < 1.5.1 # rec.dtype.names = list(rec.dtype.names)[::-1] - index = self.frame.index + index = float_frame.index df = DataFrame(rec) tm.assert_index_equal(df.columns, pd.Index(rec.dtype.names)) @@ -228,24 +228,24 @@ def test_constructor_ordereddict(self): assert expected == list(df.columns) def test_constructor_dict(self): - frame = DataFrame({'col1': self.ts1, - 'col2': self.ts2}) + frame = DataFrame({'col1': datetime_series, + 'col2': datetime_series_short}) # col2 is padded with NaN - assert len(self.ts1) == 30 - assert len(self.ts2) == 25 + assert len(datetime_series) == 30 + assert len(datetime_series_short) == 25 - tm.assert_series_equal(self.ts1, frame['col1'], check_names=False) + tm.assert_series_equal(datetime_series, frame['col1'], check_names=False) - exp = pd.Series(np.concatenate([[np.nan] * 5, self.ts2.values]), - index=self.ts1.index, name='col2') + exp = pd.Series(np.concatenate([[np.nan] * 5, datetime_series_short.values]), + index=datetime_series.index, name='col2') tm.assert_series_equal(exp, frame['col2']) - frame = DataFrame({'col1': self.ts1, - 'col2': self.ts2}, + frame = DataFrame({'col1': datetime_series, + 'col2': datetime_series_short}, columns=['col2', 'col3', 'col4']) - assert len(frame) == len(self.ts2) + assert len(frame) == len(datetime_series_short) assert 'col1' not in frame assert isna(frame['col3']).all() @@ -347,7 +347,7 @@ def test_constructor_dict_nan_tuple_key(self, value): def test_constructor_dict_order_insertion(self): # GH19018 # initialization ordering: by insertion order if python>= 3.6 - d = {'b': self.ts2, 'a': self.ts1} + d = {'b': datetime_series_short, 'a': datetime_series} frame = DataFrame(data=d) expected = DataFrame(data=d, columns=list('ba')) tm.assert_frame_equal(frame, expected) @@ -356,7 +356,7 @@ def test_constructor_dict_order_insertion(self): def test_constructor_dict_order_by_values(self): # GH19018 # initialization ordering: by value if python<3.6 - d = {'b': self.ts2, 'a': self.ts1} + d = {'b': datetime_series_short, 'a': datetime_series} frame = DataFrame(data=d) expected = DataFrame(data=d, columns=list('ab')) tm.assert_frame_equal(frame, expected) @@ -444,13 +444,13 @@ def test_constructor_subclass_dict(self): # try with defaultdict from collections import defaultdict data = {} - self.frame['B'][:10] = np.nan - for k, v in compat.iteritems(self.frame): + float_frame['B'][:10] = np.nan + for k, v in compat.iteritems(float_frame): dct = defaultdict(dict) dct.update(v.to_dict()) data[k] = dct frame = DataFrame(data) - tm.assert_frame_equal(self.frame.sort_index(), frame) + tm.assert_frame_equal(float_frame.sort_index(), frame) def test_constructor_dict_block(self): expected = np.array([[4., 3., 2., 1.]]) @@ -838,10 +838,10 @@ def test_constructor_arrays_and_scalars(self): DataFrame({'a': False, 'b': True}) def test_constructor_DataFrame(self): - df = DataFrame(self.frame) - tm.assert_frame_equal(df, self.frame) + df = DataFrame(float_frame) + tm.assert_frame_equal(df, float_frame) - df_casted = DataFrame(self.frame, dtype=np.int64) + df_casted = DataFrame(float_frame, dtype=np.int64) assert df_casted.values.dtype == np.int64 def test_constructor_more(self): @@ -870,8 +870,8 @@ def test_constructor_more(self): with tm.assert_raises_regex(ValueError, 'cast'): DataFrame(mat, index=[0, 1], columns=[0], dtype=float) - dm = DataFrame(DataFrame(self.frame._series)) - tm.assert_frame_equal(dm, self.frame) + dm = DataFrame(DataFrame(float_frame._series)) + tm.assert_frame_equal(dm, float_frame) # int cast dm = DataFrame({'A': np.ones(10, dtype=int), @@ -1125,7 +1125,7 @@ def test_constructor_scalar(self): tm.assert_frame_equal(df, expected, check_dtype=False) def test_constructor_Series_copy_bug(self): - df = DataFrame(self.frame['A'], index=self.frame.index, columns=['A']) + df = DataFrame(float_frame['A'], index=float_frame.index, columns=['A']) df.copy() def test_constructor_mixed_dict_and_Series(self): @@ -1167,9 +1167,9 @@ def test_constructor_namedtuples(self): tm.assert_frame_equal(result, expected) def test_constructor_orient(self): - data_dict = self.mixed_frame.T._series + data_dict = float_string_frame.T._series recons = DataFrame.from_dict(data_dict, orient='index') - expected = self.mixed_frame.sort_index() + expected = float_string_frame.sort_index() tm.assert_frame_equal(recons, expected) # dict of sequence @@ -1272,37 +1272,37 @@ def test_constructor_Series_differently_indexed(self): tm.assert_frame_equal(df2, exp2) def test_constructor_manager_resize(self): - index = list(self.frame.index[:5]) - columns = list(self.frame.columns[:3]) + index = list(float_frame.index[:5]) + columns = list(float_frame.columns[:3]) - result = DataFrame(self.frame._data, index=index, + result = DataFrame(float_frame._data, index=index, columns=columns) tm.assert_index_equal(result.index, Index(index)) tm.assert_index_equal(result.columns, Index(columns)) def test_constructor_from_items(self): - items = [(c, self.frame[c]) for c in self.frame.columns] + items = [(c, float_frame[c]) for c in float_frame.columns] with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): recons = DataFrame.from_items(items) - tm.assert_frame_equal(recons, self.frame) + tm.assert_frame_equal(recons, float_frame) # pass some columns with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): recons = DataFrame.from_items(items, columns=['C', 'B', 'A']) - tm.assert_frame_equal(recons, self.frame.loc[:, ['C', 'B', 'A']]) + tm.assert_frame_equal(recons, float_frame.loc[:, ['C', 'B', 'A']]) # orient='index' - row_items = [(idx, self.mixed_frame.xs(idx)) - for idx in self.mixed_frame.index] + row_items = [(idx, float_string_frame.xs(idx)) + for idx in float_string_frame.index] with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): recons = DataFrame.from_items(row_items, - columns=self.mixed_frame.columns, + columns=float_string_frame.columns, orient='index') - tm.assert_frame_equal(recons, self.mixed_frame) + tm.assert_frame_equal(recons, float_string_frame) assert recons['A'].dtype == np.float64 with tm.assert_raises_regex(TypeError, @@ -1314,16 +1314,16 @@ def test_constructor_from_items(self): # orient='index', but thar be tuples arr = construct_1d_object_array_from_listlike( - [('bar', 'baz')] * len(self.mixed_frame)) - self.mixed_frame['foo'] = arr - row_items = [(idx, list(self.mixed_frame.xs(idx))) - for idx in self.mixed_frame.index] + [('bar', 'baz')] * len(float_string_frame)) + float_string_frame['foo'] = arr + row_items = [(idx, list(float_string_frame.xs(idx))) + for idx in float_string_frame.index] with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): recons = DataFrame.from_items(row_items, - columns=self.mixed_frame.columns, + columns=float_string_frame.columns, orient='index') - tm.assert_frame_equal(recons, self.mixed_frame) + tm.assert_frame_equal(recons, float_string_frame) assert isinstance(recons['foo'][0], tuple) with tm.assert_produces_warning(FutureWarning, @@ -1365,13 +1365,13 @@ def test_from_items_deprecation(self): orient='index') def test_constructor_mix_series_nonseries(self): - df = DataFrame({'A': self.frame['A'], - 'B': list(self.frame['B'])}, columns=['A', 'B']) - tm.assert_frame_equal(df, self.frame.loc[:, ['A', 'B']]) + df = DataFrame({'A': float_frame['A'], + 'B': list(float_frame['B'])}, columns=['A', 'B']) + tm.assert_frame_equal(df, float_frame.loc[:, ['A', 'B']]) with tm.assert_raises_regex(ValueError, 'does not match ' 'index length'): - DataFrame({'A': self.frame['A'], 'B': list(self.frame['B'])[:-2]}) + DataFrame({'A': float_frame['A'], 'B': list(float_frame['B'])[:-2]}) def test_constructor_miscast_na_int_dtype(self): df = DataFrame([[np.nan, 1], [1, 0]], dtype=np.int64) @@ -1626,23 +1626,23 @@ def test_constructor_for_list_with_dtypes(self): tm.assert_series_equal(result, expected) def test_constructor_frame_copy(self): - cop = DataFrame(self.frame, copy=True) + cop = DataFrame(float_frame, copy=True) cop['A'] = 5 assert (cop['A'] == 5).all() - assert not (self.frame['A'] == 5).all() + assert not (float_frame['A'] == 5).all() def test_constructor_ndarray_copy(self): - df = DataFrame(self.frame.values) + df = DataFrame(float_frame.values) - self.frame.values[5] = 5 + float_frame.values[5] = 5 assert (df.values[5] == 5).all() - df = DataFrame(self.frame.values, copy=True) - self.frame.values[6] = 6 + df = DataFrame(float_frame.values, copy=True) + float_frame.values[6] = 6 assert not (df.values[6] == 6).all() def test_constructor_series_copy(self): - series = self.frame._series + series = float_frame._series df = DataFrame({'A': series['A']}) df['A'][:] = 5 diff --git a/pandas/tests/frame/test_dtypes.py b/pandas/tests/frame/test_dtypes.py index c91370dc36770..dd6b2e04c15f0 100644 --- a/pandas/tests/frame/test_dtypes.py +++ b/pandas/tests/frame/test_dtypes.py @@ -395,10 +395,10 @@ def test_select_dtypes_typecodes(self): assert_frame_equal(df.select_dtypes(FLOAT_TYPES), expected) def test_dtypes_gh8722(self): - self.mixed_frame['bool'] = self.mixed_frame['A'] > 0 - result = self.mixed_frame.dtypes + float_string_frame['bool'] = float_string_frame['A'] > 0 + result = float_string_frame.dtypes expected = Series({k: v.dtype - for k, v in compat.iteritems(self.mixed_frame)}, + for k, v in compat.iteritems(float_string_frame)}, index=result.index) assert_series_equal(result, expected) @@ -409,7 +409,7 @@ def test_dtypes_gh8722(self): assert_series_equal(result, Series({0: np.dtype('int64')})) def test_ftypes(self): - frame = self.mixed_float + frame = mixed_float_frame expected = Series(dict(A='float32:dense', B='float32:dense', C='float16:dense', @@ -418,23 +418,23 @@ def test_ftypes(self): assert_series_equal(result, expected) def test_astype(self): - casted = self.frame.astype(int) - expected = DataFrame(self.frame.values.astype(int), - index=self.frame.index, - columns=self.frame.columns) + casted = float_frame.astype(int) + expected = DataFrame(float_frame.values.astype(int), + index=float_frame.index, + columns=float_frame.columns) assert_frame_equal(casted, expected) - casted = self.frame.astype(np.int32) - expected = DataFrame(self.frame.values.astype(np.int32), - index=self.frame.index, - columns=self.frame.columns) + casted = float_frame.astype(np.int32) + expected = DataFrame(float_frame.values.astype(np.int32), + index=float_frame.index, + columns=float_frame.columns) assert_frame_equal(casted, expected) - self.frame['foo'] = '5' - casted = self.frame.astype(int) - expected = DataFrame(self.frame.values.astype(int), - index=self.frame.index, - columns=self.frame.columns) + float_frame['foo'] = '5' + casted = float_frame.astype(int) + expected = DataFrame(float_frame.values.astype(int), + index=float_frame.index, + columns=float_frame.columns) assert_frame_equal(casted, expected) # mixed casting @@ -442,7 +442,7 @@ def _check_cast(df, v): assert (list({s.dtype.name for _, s in compat.iteritems(df)})[0] == v) - mn = self.all_mixed._get_numeric_data().copy() + mn = mixed_type_frame._get_numeric_data().copy() mn['little_float'] = np.array(12345., dtype='float16') mn['big_float'] = np.array(123456789101112., dtype='float64') @@ -452,13 +452,13 @@ def _check_cast(df, v): casted = mn.astype('int64') _check_cast(casted, 'int64') - casted = self.mixed_float.reindex(columns=['A', 'B']).astype('float32') + casted = mixed_float_frame.reindex(columns=['A', 'B']).astype('float32') _check_cast(casted, 'float32') casted = mn.reindex(columns=['little_float']).astype('float16') _check_cast(casted, 'float16') - casted = self.mixed_float.reindex(columns=['A', 'B']).astype('float16') + casted = mixed_float_frame.reindex(columns=['A', 'B']).astype('float16') _check_cast(casted, 'float16') casted = mn.astype('float32') @@ -472,16 +472,16 @@ def _check_cast(df, v): _check_cast(casted, 'object') def test_astype_with_exclude_string(self): - df = self.frame.copy() - expected = self.frame.astype(int) + df = float_frame.copy() + expected = float_frame.astype(int) df['string'] = 'foo' casted = df.astype(int, errors='ignore') expected['string'] = 'foo' assert_frame_equal(casted, expected) - df = self.frame.copy() - expected = self.frame.astype(np.int32) + df = float_frame.copy() + expected = float_frame.astype(np.int32) df['string'] = 'foo' casted = df.astype(np.int32, errors='ignore') @@ -490,18 +490,18 @@ def test_astype_with_exclude_string(self): def test_astype_with_view(self): - tf = self.mixed_float.reindex(columns=['A', 'B', 'C']) + tf = mixed_float_frame.reindex(columns=['A', 'B', 'C']) casted = tf.astype(np.int64) casted = tf.astype(np.float32) # this is the only real reason to do it this way - tf = np.round(self.frame).astype(np.int32) + tf = np.round(float_frame).astype(np.int32) casted = tf.astype(np.float32, copy=False) # TODO(wesm): verification? - tf = self.frame.astype(np.float64) + tf = float_frame.astype(np.float64) casted = tf.astype(np.int64, copy=False) # noqa @pytest.mark.parametrize("dtype", [np.int32, np.int64]) @@ -853,7 +853,7 @@ class TestDataFrameDatetimeWithTZ(TestData): def test_interleave(self): # interleave with object - result = self.tzframe.assign(D='foo').values + result = timezone_frame.assign(D='foo').values expected = np.array([[Timestamp('2013-01-01 00:00:00'), Timestamp('2013-01-02 00:00:00'), Timestamp('2013-01-03 00:00:00')], @@ -869,7 +869,7 @@ def test_interleave(self): tm.assert_numpy_array_equal(result, expected) # interleave with only datetime64[ns] - result = self.tzframe.values + result = timezone_frame.values expected = np.array([[Timestamp('2013-01-01 00:00:00'), Timestamp('2013-01-02 00:00:00'), Timestamp('2013-01-03 00:00:00')], @@ -899,11 +899,11 @@ def test_astype(self): Timestamp('2013-01-03 00:00:00+0100', tz='CET')]], dtype=object).T - result = self.tzframe.astype(object) + result = timezone_frame.astype(object) assert_frame_equal(result, DataFrame( - expected, index=self.tzframe.index, columns=self.tzframe.columns)) + expected, index=timezone_frame.index, columns=timezone_frame.columns)) - result = self.tzframe.astype('datetime64[ns]') + result = timezone_frame.astype('datetime64[ns]') expected = DataFrame({'A': date_range('20130101', periods=3), 'B': (date_range('20130101', periods=3, tz='US/Eastern') @@ -919,17 +919,17 @@ def test_astype(self): def test_astype_str(self): # str formatting - result = self.tzframe.astype(str) + result = timezone_frame.astype(str) expected = DataFrame([['2013-01-01', '2013-01-01 00:00:00-05:00', '2013-01-01 00:00:00+01:00'], ['2013-01-02', 'NaT', 'NaT'], ['2013-01-03', '2013-01-03 00:00:00-05:00', '2013-01-03 00:00:00+01:00']], - columns=self.tzframe.columns) + columns=timezone_frame.columns) tm.assert_frame_equal(result, expected) with option_context('display.max_columns', 20): - result = str(self.tzframe) + result = str(timezone_frame) assert ('0 2013-01-01 2013-01-01 00:00:00-05:00 ' '2013-01-01 00:00:00+01:00') in result assert ('1 2013-01-02 ' diff --git a/pandas/tests/frame/test_indexing.py b/pandas/tests/frame/test_indexing.py index 2b93af357481a..b28a2e73ea167 100644 --- a/pandas/tests/frame/test_indexing.py +++ b/pandas/tests/frame/test_indexing.py @@ -42,7 +42,7 @@ class TestDataFrameIndexing(TestData): def test_getitem(self): # Slicing - sl = self.frame[:20] + sl = float_frame[:20] assert len(sl.index) == 20 # Column access @@ -50,14 +50,14 @@ def test_getitem(self): assert len(series.index) == 20 assert tm.equalContents(series.index, sl.index) - for key, _ in compat.iteritems(self.frame._series): - assert self.frame[key] is not None + for key, _ in compat.iteritems(float_frame._series): + assert float_frame[key] is not None - assert 'random' not in self.frame + assert 'random' not in float_frame with tm.assert_raises_regex(KeyError, 'random'): - self.frame['random'] + float_frame['random'] - df = self.frame.copy() + df = float_frame.copy() df['$10'] = randn(len(df)) ad = randn(len(df)) @@ -75,12 +75,12 @@ def test_getitem_dupe_cols(self): df[['baf']] def test_get(self): - b = self.frame.get('B') - assert_series_equal(b, self.frame['B']) + b = float_frame.get('B') + assert_series_equal(b, float_frame['B']) - assert self.frame.get('foo') is None - assert_series_equal(self.frame.get('foo', self.frame['B']), - self.frame['B']) + assert float_frame.get('foo') is None + assert_series_equal(float_frame.get('foo', float_frame['B']), + float_frame['B']) @pytest.mark.parametrize("df", [ DataFrame(), @@ -93,8 +93,8 @@ def test_get_none(self, df): def test_loc_iterable(self): idx = iter(['A', 'B', 'C']) - result = self.frame.loc[:, idx] - expected = self.frame.loc[:, ['A', 'B', 'C']] + result = float_frame.loc[:, idx] + expected = float_frame.loc[:, ['A', 'B', 'C']] assert_frame_equal(result, expected) @pytest.mark.parametrize( @@ -108,7 +108,7 @@ def test_getitem_listlike(self, idx_type, levels): # GH 21294 if levels == 1: - frame, missing = self.frame, 'food' + frame, missing = float_frame, 'food' else: # MultiIndex columns frame = DataFrame(randn(8, 3), @@ -134,28 +134,28 @@ def test_getitem_listlike(self, idx_type, levels): def test_getitem_callable(self): # GH 12533 - result = self.frame[lambda x: 'A'] - tm.assert_series_equal(result, self.frame.loc[:, 'A']) + result = float_frame[lambda x: 'A'] + tm.assert_series_equal(result, float_frame.loc[:, 'A']) - result = self.frame[lambda x: ['A', 'B']] - tm.assert_frame_equal(result, self.frame.loc[:, ['A', 'B']]) + result = float_frame[lambda x: ['A', 'B']] + tm.assert_frame_equal(result, float_frame.loc[:, ['A', 'B']]) - df = self.frame[:3] + df = float_frame[:3] result = df[lambda x: [True, False, True]] - tm.assert_frame_equal(result, self.frame.iloc[[0, 2], :]) + tm.assert_frame_equal(result, float_frame.iloc[[0, 2], :]) def test_setitem_list(self): - self.frame['E'] = 'foo' - data = self.frame[['A', 'B']] - self.frame[['B', 'A']] = data + float_frame['E'] = 'foo' + data = float_frame[['A', 'B']] + float_frame[['B', 'A']] = data - assert_series_equal(self.frame['B'], data['A'], check_names=False) - assert_series_equal(self.frame['A'], data['B'], check_names=False) + assert_series_equal(float_frame['B'], data['A'], check_names=False) + assert_series_equal(float_frame['A'], data['B'], check_names=False) with tm.assert_raises_regex(ValueError, 'Columns must be same length as key'): - data[['A']] = self.frame[['A', 'B']] + data[['A']] = float_frame[['A', 'B']] with tm.assert_raises_regex(ValueError, 'Length of values ' 'does not match ' @@ -176,16 +176,16 @@ def test_setitem_list(self): assert_series_equal(result, expected) def test_setitem_list_not_dataframe(self): - data = np.random.randn(len(self.frame), 2) - self.frame[['A', 'B']] = data - assert_almost_equal(self.frame[['A', 'B']].values, data) + data = np.random.randn(len(float_frame), 2) + float_frame[['A', 'B']] = data + assert_almost_equal(float_frame[['A', 'B']].values, data) def test_setitem_list_of_tuples(self): - tuples = lzip(self.frame['A'], self.frame['B']) - self.frame['tuples'] = tuples + tuples = lzip(float_frame['A'], float_frame['B']) + float_frame['tuples'] = tuples - result = self.frame['tuples'] - expected = Series(tuples, index=self.frame.index, name='tuples') + result = float_frame['tuples'] + expected = Series(tuples, index=float_frame.index, name='tuples') assert_series_equal(result, expected) def test_setitem_mulit_index(self): @@ -234,27 +234,27 @@ def inc(x): def test_getitem_boolean(self): # boolean indexing - d = self.tsframe.index[10] - indexer = self.tsframe.index > d + d = datetime_frame.index[10] + indexer = datetime_frame.index > d indexer_obj = indexer.astype(object) - subindex = self.tsframe.index[indexer] - subframe = self.tsframe[indexer] + subindex = datetime_frame.index[indexer] + subframe = datetime_frame[indexer] tm.assert_index_equal(subindex, subframe.index) with tm.assert_raises_regex(ValueError, 'Item wrong length'): - self.tsframe[indexer[:-1]] + datetime_frame[indexer[:-1]] - subframe_obj = self.tsframe[indexer_obj] + subframe_obj = datetime_frame[indexer_obj] assert_frame_equal(subframe_obj, subframe) with tm.assert_raises_regex(ValueError, 'boolean values only'): - self.tsframe[self.tsframe] + datetime_frame[datetime_frame] # test that Series work - indexer_obj = Series(indexer_obj, self.tsframe.index) + indexer_obj = Series(indexer_obj, datetime_frame.index) - subframe_obj = self.tsframe[indexer_obj] + subframe_obj = datetime_frame[indexer_obj] assert_frame_equal(subframe_obj, subframe) # test that Series indexers reindex @@ -262,14 +262,14 @@ def test_getitem_boolean(self): # key is not the same as the given index, we will reindex # not sure this is really necessary with tm.assert_produces_warning(UserWarning, check_stacklevel=False): - indexer_obj = indexer_obj.reindex(self.tsframe.index[::-1]) - subframe_obj = self.tsframe[indexer_obj] + indexer_obj = indexer_obj.reindex(datetime_frame.index[::-1]) + subframe_obj = datetime_frame[indexer_obj] assert_frame_equal(subframe_obj, subframe) # test df[df > 0] - for df in [self.tsframe, self.mixed_frame, - self.mixed_float, self.mixed_int]: - if compat.PY3 and df is self.mixed_frame: + for df in [datetime_frame, float_string_frame, + mixed_float_frame, mixed_int_frame]: + if compat.PY3 and df is float_string_frame: continue data = df._get_numeric_data() @@ -292,7 +292,7 @@ def test_getitem_boolean(self): def test_getitem_boolean_casting(self): # don't upcast if we don't need to - df = self.tsframe.copy() + df = datetime_frame.copy() df['E'] = 1 df['E'] = df['E'].astype('int32') df['E1'] = df['E'].copy() @@ -385,23 +385,23 @@ def test_getitem_ix_mixed_integer(self): def test_getitem_setitem_ix_negative_integers(self): with catch_warnings(record=True): simplefilter("ignore", DeprecationWarning) - result = self.frame.ix[:, -1] - assert_series_equal(result, self.frame['D']) + result = float_frame.ix[:, -1] + assert_series_equal(result, float_frame['D']) with catch_warnings(record=True): simplefilter("ignore", DeprecationWarning) - result = self.frame.ix[:, [-1]] - assert_frame_equal(result, self.frame[['D']]) + result = float_frame.ix[:, [-1]] + assert_frame_equal(result, float_frame[['D']]) with catch_warnings(record=True): simplefilter("ignore", DeprecationWarning) - result = self.frame.ix[:, [-1, -2]] - assert_frame_equal(result, self.frame[['D', 'C']]) + result = float_frame.ix[:, [-1, -2]] + assert_frame_equal(result, float_frame[['D', 'C']]) with catch_warnings(record=True): simplefilter("ignore", DeprecationWarning) - self.frame.ix[:, [-1]] = 0 - assert (self.frame['D'] == 0).all() + float_frame.ix[:, [-1]] = 0 + assert (float_frame['D'] == 0).all() df = DataFrame(np.random.randn(8, 4)) # ix does label-based indexing when having an integer index @@ -428,8 +428,8 @@ def test_getitem_setitem_ix_negative_integers(self): assert a.ix[-2].name == 'S' def test_getattr(self): - assert_series_equal(self.frame.A, self.frame['A']) - pytest.raises(AttributeError, getattr, self.frame, + assert_series_equal(float_frame.A, float_frame['A']) + pytest.raises(AttributeError, getattr, float_frame, 'NONEXISTENT_NAME') def test_setattr_column(self): @@ -440,41 +440,41 @@ def test_setattr_column(self): def test_setitem(self): # not sure what else to do here - series = self.frame['A'][::2] - self.frame['col5'] = series - assert 'col5' in self.frame + series = float_frame['A'][::2] + float_frame['col5'] = series + assert 'col5' in float_frame assert len(series) == 15 - assert len(self.frame) == 30 + assert len(float_frame) == 30 exp = np.ravel(np.column_stack((series.values, [np.nan] * 15))) - exp = Series(exp, index=self.frame.index, name='col5') - tm.assert_series_equal(self.frame['col5'], exp) + exp = Series(exp, index=float_frame.index, name='col5') + tm.assert_series_equal(float_frame['col5'], exp) - series = self.frame['A'] - self.frame['col6'] = series - tm.assert_series_equal(series, self.frame['col6'], check_names=False) + series = float_frame['A'] + float_frame['col6'] = series + tm.assert_series_equal(series, float_frame['col6'], check_names=False) with pytest.raises(KeyError): - self.frame[randn(len(self.frame) + 1)] = 1 + float_frame[randn(len(float_frame) + 1)] = 1 # set ndarray - arr = randn(len(self.frame)) - self.frame['col9'] = arr - assert (self.frame['col9'] == arr).all() + arr = randn(len(float_frame)) + float_frame['col9'] = arr + assert (float_frame['col9'] == arr).all() - self.frame['col7'] = 5 - assert((self.frame['col7'] == 5).all()) + float_frame['col7'] = 5 + assert((float_frame['col7'] == 5).all()) - self.frame['col0'] = 3.14 - assert((self.frame['col0'] == 3.14).all()) + float_frame['col0'] = 3.14 + assert((float_frame['col0'] == 3.14).all()) - self.frame['col8'] = 'foo' - assert((self.frame['col8'] == 'foo').all()) + float_frame['col8'] = 'foo' + assert((float_frame['col8'] == 'foo').all()) # this is partially a view (e.g. some blocks are view) # so raise/warn - smaller = self.frame[:2] + smaller = float_frame[:2] def f(): smaller['col10'] = ['1', '2'] @@ -494,26 +494,26 @@ def f(): @pytest.mark.parametrize("dtype", ["int32", "int64", "float32", "float64"]) def test_setitem_dtype(self, dtype): - arr = randn(len(self.frame)) + arr = randn(len(float_frame)) - self.frame[dtype] = np.array(arr, dtype=dtype) - assert self.frame[dtype].dtype.name == dtype + float_frame[dtype] = np.array(arr, dtype=dtype) + assert float_frame[dtype].dtype.name == dtype def test_setitem_tuple(self): - self.frame['A', 'B'] = self.frame['A'] - assert_series_equal(self.frame['A', 'B'], self.frame[ + float_frame['A', 'B'] = float_frame['A'] + assert_series_equal(float_frame['A', 'B'], float_frame[ 'A'], check_names=False) def test_setitem_always_copy(self): - s = self.frame['A'].copy() - self.frame['E'] = s + s = float_frame['A'].copy() + float_frame['E'] = s - self.frame['E'][5:10] = nan + float_frame['E'][5:10] = nan assert notna(s[5:10]).all() def test_setitem_boolean(self): - df = self.frame.copy() - values = self.frame.values + df = float_frame.copy() + values = float_frame.values df[df['A'] > 0] = 4 values[values[:, 0] > 0] = 4 @@ -569,7 +569,7 @@ def test_setitem_boolean(self): def test_setitem_boolean_mask(self, mask_type): # Test for issue #18582 - df = self.frame.copy() + df = float_frame.copy() mask = mask_type(df) # index with boolean mask @@ -581,33 +581,33 @@ def test_setitem_boolean_mask(self, mask_type): assert_frame_equal(result, expected) def test_setitem_cast(self): - self.frame['D'] = self.frame['D'].astype('i8') - assert self.frame['D'].dtype == np.int64 + float_frame['D'] = float_frame['D'].astype('i8') + assert float_frame['D'].dtype == np.int64 # #669, should not cast? # this is now set to int64, which means a replacement of the column to # the value dtype (and nothing to do with the existing dtype) - self.frame['B'] = 0 - assert self.frame['B'].dtype == np.int64 + float_frame['B'] = 0 + assert float_frame['B'].dtype == np.int64 # cast if pass array of course - self.frame['B'] = np.arange(len(self.frame)) - assert issubclass(self.frame['B'].dtype.type, np.integer) + float_frame['B'] = np.arange(len(float_frame)) + assert issubclass(float_frame['B'].dtype.type, np.integer) - self.frame['foo'] = 'bar' - self.frame['foo'] = 0 - assert self.frame['foo'].dtype == np.int64 + float_frame['foo'] = 'bar' + float_frame['foo'] = 0 + assert float_frame['foo'].dtype == np.int64 - self.frame['foo'] = 'bar' - self.frame['foo'] = 2.5 - assert self.frame['foo'].dtype == np.float64 + float_frame['foo'] = 'bar' + float_frame['foo'] = 2.5 + assert float_frame['foo'].dtype == np.float64 - self.frame['something'] = 0 - assert self.frame['something'].dtype == np.int64 - self.frame['something'] = 2 - assert self.frame['something'].dtype == np.int64 - self.frame['something'] = 2.5 - assert self.frame['something'].dtype == np.float64 + float_frame['something'] = 0 + assert float_frame['something'].dtype == np.int64 + float_frame['something'] = 2 + assert float_frame['something'].dtype == np.int64 + float_frame['something'] = 2.5 + assert float_frame['something'].dtype == np.float64 # GH 7704 # dtype conversion on setting @@ -626,13 +626,13 @@ def test_setitem_cast(self): assert df.dtypes.one == np.dtype(np.int8) def test_setitem_boolean_column(self): - expected = self.frame.copy() - mask = self.frame['A'] > 0 + expected = float_frame.copy() + mask = float_frame['A'] > 0 - self.frame.loc[mask, 'B'] = 0 + float_frame.loc[mask, 'B'] = 0 expected.values[mask.values, 1] = 0 - assert_frame_equal(self.frame, expected) + assert_frame_equal(float_frame, expected) def test_frame_setitem_timestamp(self): # GH#2155 @@ -661,7 +661,7 @@ def test_setitem_corner(self): df[datetime.now()] = 5. # what to do when empty frame with index - dm = DataFrame(index=self.frame.index) + dm = DataFrame(index=float_frame.index) dm['A'] = 'foo' dm['B'] = 'bar' assert len(dm.columns) == 2 @@ -739,14 +739,14 @@ def test_setitem_clear_caches(self): def test_setitem_None(self): # GH #766 - self.frame[None] = self.frame['A'] + float_frame[None] = float_frame['A'] assert_series_equal( - self.frame.iloc[:, -1], self.frame['A'], check_names=False) - assert_series_equal(self.frame.loc[:, None], self.frame[ + float_frame.iloc[:, -1], float_frame['A'], check_names=False) + assert_series_equal(float_frame.loc[:, None], float_frame[ 'A'], check_names=False) - assert_series_equal(self.frame[None], self.frame[ + assert_series_equal(float_frame[None], float_frame[ 'A'], check_names=False) - repr(self.frame) + repr(float_frame) def test_setitem_empty(self): # GH 9596 @@ -788,7 +788,7 @@ def test_getitem_empty_frame_with_boolean(self): assert_frame_equal(df, df2) def test_delitem_corner(self): - f = self.frame.copy() + f = float_frame.copy() del f['D'] assert len(f.columns) == 3 pytest.raises(KeyError, f.__delitem__, 'D') @@ -796,14 +796,14 @@ def test_delitem_corner(self): assert len(f.columns) == 2 def test_getitem_fancy_2d(self): - f = self.frame + f = float_frame with catch_warnings(record=True): simplefilter("ignore", DeprecationWarning) assert_frame_equal(f.ix[:, ['B', 'A']], f.reindex(columns=['B', 'A'])) - subidx = self.frame.index[[5, 4, 1]] + subidx = float_frame.index[[5, 4, 1]] with catch_warnings(record=True): simplefilter("ignore", DeprecationWarning) assert_frame_equal(f.ix[subidx, ['B', 'A']], @@ -891,7 +891,7 @@ def test_getitem_setitem_integer_slice_keyerrors(self): def test_setitem_fancy_2d(self): # case 1 - frame = self.frame.copy() + frame = float_frame.copy() expected = frame.copy() with catch_warnings(record=True): @@ -902,12 +902,12 @@ def test_setitem_fancy_2d(self): assert_frame_equal(frame, expected) # case 2 - frame = self.frame.copy() - frame2 = self.frame.copy() + frame = float_frame.copy() + frame2 = float_frame.copy() expected = frame.copy() - subidx = self.frame.index[[5, 4, 1]] + subidx = float_frame.index[[5, 4, 1]] values = randn(3, 2) with catch_warnings(record=True): @@ -922,18 +922,18 @@ def test_setitem_fancy_2d(self): assert_frame_equal(frame2, expected) # case 3: slicing rows, etc. - frame = self.frame.copy() + frame = float_frame.copy() with catch_warnings(record=True): simplefilter("ignore", DeprecationWarning) - expected1 = self.frame.copy() + expected1 = float_frame.copy() frame.ix[5:10] = 1. expected1.values[5:10] = 1. assert_frame_equal(frame, expected1) with catch_warnings(record=True): simplefilter("ignore", DeprecationWarning) - expected2 = self.frame.copy() + expected2 = float_frame.copy() arr = randn(5, len(frame.columns)) frame.ix[5:10] = arr expected2.values[5:10] = arr @@ -942,7 +942,7 @@ def test_setitem_fancy_2d(self): # case 4 with catch_warnings(record=True): simplefilter("ignore", DeprecationWarning) - frame = self.frame.copy() + frame = float_frame.copy() frame.ix[5:10, :] = 1. assert_frame_equal(frame, expected1) frame.ix[5:10, :] = arr @@ -951,10 +951,10 @@ def test_setitem_fancy_2d(self): # case 5 with catch_warnings(record=True): simplefilter("ignore", DeprecationWarning) - frame = self.frame.copy() - frame2 = self.frame.copy() + frame = float_frame.copy() + frame2 = float_frame.copy() - expected = self.frame.copy() + expected = float_frame.copy() values = randn(5, 2) frame.ix[:5, ['A', 'B']] = values @@ -970,8 +970,8 @@ def test_setitem_fancy_2d(self): # case 6: slice rows with labels, inclusive! with catch_warnings(record=True): simplefilter("ignore", DeprecationWarning) - frame = self.frame.copy() - expected = self.frame.copy() + frame = float_frame.copy() + expected = float_frame.copy() frame.ix[frame.index[5]:frame.index[10]] = 5. expected.values[5:11] = 5 @@ -980,9 +980,9 @@ def test_setitem_fancy_2d(self): # case 7: slice columns with catch_warnings(record=True): simplefilter("ignore", DeprecationWarning) - frame = self.frame.copy() - frame2 = self.frame.copy() - expected = self.frame.copy() + frame = float_frame.copy() + frame2 = float_frame.copy() + expected = float_frame.copy() # slice indices frame.ix[:, 1:3] = 4. @@ -1004,17 +1004,17 @@ def test_setitem_fancy_2d(self): assert_frame_equal(frame, expected) def test_fancy_getitem_slice_mixed(self): - sliced = self.mixed_frame.iloc[:, -3:] + sliced = float_string_frame.iloc[:, -3:] assert sliced['D'].dtype == np.float64 # get view with single block # setting it triggers setting with copy - sliced = self.frame.iloc[:, -3:] + sliced = float_frame.iloc[:, -3:] def f(): sliced['C'] = 4. pytest.raises(com.SettingWithCopyError, f) - assert (self.frame['C'] == 4).all() + assert (float_frame['C'] == 4).all() def test_fancy_setitem_int_labels(self): # integer index defers to label-based indexing @@ -1086,28 +1086,28 @@ def test_fancy_index_int_labels_exceptions(self): ([0, 1, 2], [2, 3, 4]), 5) # try to set indices not contained in frame - pytest.raises(KeyError, self.frame.ix.__setitem__, + pytest.raises(KeyError, float_frame.ix.__setitem__, ['foo', 'bar', 'baz'], 1) - pytest.raises(KeyError, self.frame.ix.__setitem__, + pytest.raises(KeyError, float_frame.ix.__setitem__, (slice(None, None), ['E']), 1) # partial setting now allows this GH2578 - # pytest.raises(KeyError, self.frame.ix.__setitem__, + # pytest.raises(KeyError, float_frame.ix.__setitem__, # (slice(None, None), 'E'), 1) def test_setitem_fancy_mixed_2d(self): with catch_warnings(record=True): simplefilter("ignore", DeprecationWarning) - self.mixed_frame.ix[:5, ['C', 'B', 'A']] = 5 - result = self.mixed_frame.ix[:5, ['C', 'B', 'A']] + float_string_frame.ix[:5, ['C', 'B', 'A']] = 5 + result = float_string_frame.ix[:5, ['C', 'B', 'A']] assert (result.values == 5).all() - self.mixed_frame.ix[5] = np.nan - assert isna(self.mixed_frame.ix[5]).all() + float_string_frame.ix[5] = np.nan + assert isna(float_string_frame.ix[5]).all() - self.mixed_frame.ix[5] = self.mixed_frame.ix[6] - assert_series_equal(self.mixed_frame.ix[5], self.mixed_frame.ix[6], + float_string_frame.ix[5] = float_string_frame.ix[6] + assert_series_equal(float_string_frame.ix[5], float_string_frame.ix[6], check_names=False) # #1432 @@ -1267,7 +1267,7 @@ def test_ix_dup(self): assert_frame_equal(sub, df.ix[2:]) def test_getitem_fancy_1d(self): - f = self.frame + f = float_frame # return self if no slicing...for now with catch_warnings(record=True): @@ -1322,15 +1322,15 @@ def test_getitem_fancy_1d(self): # slice of mixed-frame with catch_warnings(record=True): simplefilter("ignore", DeprecationWarning) - xs = self.mixed_frame.ix[5] - exp = self.mixed_frame.xs(self.mixed_frame.index[5]) + xs = float_string_frame.ix[5] + exp = float_string_frame.xs(float_string_frame.index[5]) tm.assert_series_equal(xs, exp) def test_setitem_fancy_1d(self): # case 1: set cross-section for indices - frame = self.frame.copy() - expected = self.frame.copy() + frame = float_frame.copy() + expected = float_frame.copy() with catch_warnings(record=True): simplefilter("ignore", DeprecationWarning) @@ -1342,13 +1342,13 @@ def test_setitem_fancy_1d(self): with catch_warnings(record=True): simplefilter("ignore", DeprecationWarning) - frame2 = self.frame.copy() + frame2 = float_frame.copy() frame2.ix[2, [3, 2, 1]] = [1., 2., 3.] assert_frame_equal(frame, expected) # case 2, set a section of a column - frame = self.frame.copy() - expected = self.frame.copy() + frame = float_frame.copy() + expected = float_frame.copy() with catch_warnings(record=True): simplefilter("ignore", DeprecationWarning) @@ -1359,13 +1359,13 @@ def test_setitem_fancy_1d(self): with catch_warnings(record=True): simplefilter("ignore", DeprecationWarning) - frame2 = self.frame.copy() + frame2 = float_frame.copy() frame2.ix[5:10, 'B'] = vals assert_frame_equal(frame, expected) # case 3: full xs - frame = self.frame.copy() - expected = self.frame.copy() + frame = float_frame.copy() + expected = float_frame.copy() with catch_warnings(record=True): simplefilter("ignore", DeprecationWarning) @@ -1380,8 +1380,8 @@ def test_setitem_fancy_1d(self): assert_frame_equal(frame, expected) # single column - frame = self.frame.copy() - expected = self.frame.copy() + frame = float_frame.copy() + expected = float_frame.copy() with catch_warnings(record=True): simplefilter("ignore", DeprecationWarning) @@ -1390,7 +1390,7 @@ def test_setitem_fancy_1d(self): assert_frame_equal(frame, expected) def test_getitem_fancy_scalar(self): - f = self.frame + f = float_frame ix = f.loc # individual value @@ -1400,8 +1400,8 @@ def test_getitem_fancy_scalar(self): assert ix[idx, col] == ts[idx] def test_setitem_fancy_scalar(self): - f = self.frame - expected = self.frame.copy() + f = float_frame + expected = float_frame.copy() ix = f.loc # individual value @@ -1416,7 +1416,7 @@ def test_setitem_fancy_scalar(self): assert_frame_equal(f, expected) def test_getitem_fancy_boolean(self): - f = self.frame + f = float_frame ix = f.loc expected = f.reindex(columns=['B', 'D']) @@ -1441,31 +1441,31 @@ def test_getitem_fancy_boolean(self): def test_setitem_fancy_boolean(self): # from 2d, set with booleans - frame = self.frame.copy() - expected = self.frame.copy() + frame = float_frame.copy() + expected = float_frame.copy() mask = frame['A'] > 0 frame.loc[mask] = 0. expected.values[mask.values] = 0. assert_frame_equal(frame, expected) - frame = self.frame.copy() - expected = self.frame.copy() + frame = float_frame.copy() + expected = float_frame.copy() frame.loc[mask, ['A', 'B']] = 0. expected.values[mask.values, :2] = 0. assert_frame_equal(frame, expected) def test_getitem_fancy_ints(self): - result = self.frame.iloc[[1, 4, 7]] - expected = self.frame.loc[self.frame.index[[1, 4, 7]]] + result = float_frame.iloc[[1, 4, 7]] + expected = float_frame.loc[float_frame.index[[1, 4, 7]]] assert_frame_equal(result, expected) - result = self.frame.iloc[:, [2, 0, 1]] - expected = self.frame.loc[:, self.frame.columns[[2, 0, 1]]] + result = float_frame.iloc[:, [2, 0, 1]] + expected = float_frame.loc[:, float_frame.columns[[2, 0, 1]]] assert_frame_equal(result, expected) def test_getitem_setitem_fancy_exceptions(self): - ix = self.frame.iloc + ix = float_frame.iloc with tm.assert_raises_regex(IndexingError, 'Too many indexers'): ix[:, :, :] @@ -1474,14 +1474,14 @@ def test_getitem_setitem_fancy_exceptions(self): def test_getitem_setitem_boolean_misaligned(self): # boolean index misaligned labels - mask = self.frame['A'][::-1] > 1 + mask = float_frame['A'][::-1] > 1 - result = self.frame.loc[mask] - expected = self.frame.loc[mask[::-1]] + result = float_frame.loc[mask] + expected = float_frame.loc[mask[::-1]] assert_frame_equal(result, expected) - cp = self.frame.copy() - expected = self.frame.copy() + cp = float_frame.copy() + expected = float_frame.copy() cp.loc[mask] = 0 expected.loc[mask] = 0 assert_frame_equal(cp, expected) @@ -1642,16 +1642,16 @@ def test_setitem_mixed_datetime(self): assert_frame_equal(df, expected) def test_setitem_frame(self): - piece = self.frame.loc[self.frame.index[:2], ['A', 'B']] - self.frame.loc[self.frame.index[-2]:, ['A', 'B']] = piece.values - result = self.frame.loc[self.frame.index[-2:], ['A', 'B']].values + piece = float_frame.loc[float_frame.index[:2], ['A', 'B']] + float_frame.loc[float_frame.index[-2]:, ['A', 'B']] = piece.values + result = float_frame.loc[float_frame.index[-2:], ['A', 'B']].values expected = piece.values assert_almost_equal(result, expected) # GH 3216 # already aligned - f = self.mixed_frame.copy() + f = float_string_frame.copy() piece = DataFrame([[1., 2.], [3., 4.]], index=f.index[0:2], columns=['A', 'B']) key = (slice(None, 2), ['A', 'B']) @@ -1660,7 +1660,7 @@ def test_setitem_frame(self): piece.values) # rows unaligned - f = self.mixed_frame.copy() + f = float_string_frame.copy() piece = DataFrame([[1., 2.], [3., 4.], [5., 6.], [7., 8.]], index=list(f.index[0:2]) + ['foo', 'bar'], columns=['A', 'B']) @@ -1670,7 +1670,7 @@ def test_setitem_frame(self): piece.values[0:2]) # key is unaligned with values - f = self.mixed_frame.copy() + f = float_string_frame.copy() piece = f.loc[f.index[:2], ['A']] piece.index = f.index[-2:] key = (slice(-2, None), ['A', 'B']) @@ -1680,8 +1680,8 @@ def test_setitem_frame(self): piece.values) # ndarray - f = self.mixed_frame.copy() - piece = self.mixed_frame.loc[f.index[:2], ['A', 'B']] + f = float_string_frame.copy() + piece = float_string_frame.loc[f.index[:2], ['A', 'B']] key = (slice(-2, None), ['A', 'B']) f.loc[key] = piece.values assert_almost_equal(f.loc[f.index[-2:], ['A', 'B']].values, @@ -1697,11 +1697,11 @@ def test_setitem_frame(self): assert_frame_equal(df2, expected) def test_setitem_frame_align(self): - piece = self.frame.loc[self.frame.index[:2], ['A', 'B']] - piece.index = self.frame.index[-2:] + piece = float_frame.loc[float_frame.index[:2], ['A', 'B']] + piece.index = float_frame.index[-2:] piece.columns = ['A', 'B'] - self.frame.loc[self.frame.index[-2:], ['A', 'B']] = piece - result = self.frame.loc[self.frame.index[-2:], ['A', 'B']].values + float_frame.loc[float_frame.index[-2:], ['A', 'B']] = piece + result = float_frame.loc[float_frame.index[-2:], ['A', 'B']].values expected = piece.values assert_almost_equal(result, expected) @@ -1761,12 +1761,12 @@ def test_getitem_list_duplicates(self): assert_frame_equal(result, expected) def test_get_value(self): - for idx in self.frame.index: - for col in self.frame.columns: + for idx in float_frame.index: + for col in float_frame.columns: with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): - result = self.frame.get_value(idx, col) - expected = self.frame[col][idx] + result = float_frame.get_value(idx, col) + expected = float_frame[col][idx] assert result == expected def test_lookup(self): @@ -1785,8 +1785,8 @@ def testit(df): expected = alt(df, rows, cols, dtype=np.object_) tm.assert_almost_equal(result, expected, check_dtype=False) - testit(self.mixed_frame) - testit(self.frame) + testit(float_string_frame) + testit(float_frame) df = DataFrame({'label': ['a', 'b', 'a', 'c'], 'mask_a': [True, True, False, True], @@ -1798,51 +1798,51 @@ def testit(df): assert df['mask'].dtype == np.bool_ with pytest.raises(KeyError): - self.frame.lookup(['xyz'], ['A']) + float_frame.lookup(['xyz'], ['A']) with pytest.raises(KeyError): - self.frame.lookup([self.frame.index[0]], ['xyz']) + float_frame.lookup([float_frame.index[0]], ['xyz']) with tm.assert_raises_regex(ValueError, 'same size'): - self.frame.lookup(['a', 'b', 'c'], ['a']) + float_frame.lookup(['a', 'b', 'c'], ['a']) def test_set_value(self): - for idx in self.frame.index: - for col in self.frame.columns: + for idx in float_frame.index: + for col in float_frame.columns: with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): - self.frame.set_value(idx, col, 1) - assert self.frame[col][idx] == 1 + float_frame.set_value(idx, col, 1) + assert float_frame[col][idx] == 1 def test_set_value_resize(self): with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): - res = self.frame.set_value('foobar', 'B', 0) - assert res is self.frame + res = float_frame.set_value('foobar', 'B', 0) + assert res is float_frame assert res.index[-1] == 'foobar' with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): assert res.get_value('foobar', 'B') == 0 - self.frame.loc['foobar', 'qux'] = 0 + float_frame.loc['foobar', 'qux'] = 0 with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): - assert self.frame.get_value('foobar', 'qux') == 0 + assert float_frame.get_value('foobar', 'qux') == 0 - res = self.frame.copy() + res = float_frame.copy() with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): res3 = res.set_value('foobar', 'baz', 'sam') assert res3['baz'].dtype == np.object_ - res = self.frame.copy() + res = float_frame.copy() with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): res3 = res.set_value('foobar', 'baz', True) assert res3['baz'].dtype == np.object_ - res = self.frame.copy() + res = float_frame.copy() with tm.assert_produces_warning(FutureWarning, check_stacklevel=False): res3 = res.set_value('foobar', 'baz', 5) @@ -1891,15 +1891,15 @@ def test_get_set_value_no_partial_indexing(self): pytest.raises(KeyError, df.get_value, 0, 1) def test_single_element_ix_dont_upcast(self): - self.frame['E'] = 1 - assert issubclass(self.frame['E'].dtype.type, (int, np.integer)) + float_frame['E'] = 1 + assert issubclass(float_frame['E'].dtype.type, (int, np.integer)) with catch_warnings(record=True): simplefilter("ignore", DeprecationWarning) - result = self.frame.ix[self.frame.index[5], 'E'] + result = float_frame.ix[float_frame.index[5], 'E'] assert is_integer(result) - result = self.frame.loc[self.frame.index[5], 'E'] + result = float_frame.loc[float_frame.index[5], 'E'] assert is_integer(result) # GH 11617 @@ -2063,10 +2063,10 @@ def test_iloc_sparse_propegate_fill_value(self): def test_iat(self): - for i, row in enumerate(self.frame.index): - for j, col in enumerate(self.frame.columns): - result = self.frame.iat[i, j] - expected = self.frame.at[row, col] + for i, row in enumerate(float_frame.index): + for j, col in enumerate(float_frame.columns): + result = float_frame.iat[i, j] + expected = float_frame.at[row, col] assert result == expected def test_nested_exception(self): @@ -2396,13 +2396,13 @@ def test_at_time_between_time_datetimeindex(self): assert_frame_equal(result, df) def test_xs(self): - idx = self.frame.index[5] - xs = self.frame.xs(idx) + idx = float_frame.index[5] + xs = float_frame.xs(idx) for item, value in compat.iteritems(xs): if np.isnan(value): - assert np.isnan(self.frame[item][idx]) + assert np.isnan(float_frame[item][idx]) else: - assert value == self.frame[item][idx] + assert value == float_frame[item][idx] # mixed-type xs test_data = { @@ -2416,15 +2416,15 @@ def test_xs(self): assert xs['B'] == '1' with pytest.raises(KeyError): - self.tsframe.xs(self.tsframe.index[0] - BDay()) + datetime_frame.xs(datetime_frame.index[0] - BDay()) # xs get column - series = self.frame.xs('A', axis=1) - expected = self.frame['A'] + series = float_frame.xs('A', axis=1) + expected = float_frame['A'] assert_series_equal(series, expected) # view is returned if possible - series = self.frame.xs('A', axis=1) + series = float_frame.xs('A', axis=1) series[:] = 5 assert (expected == 5).all() @@ -2579,9 +2579,9 @@ def _check_get(df, cond, check_dtypes=True): assert (rs.dtypes == df.dtypes).all() # check getting - for df in [default_frame, self.mixed_frame, - self.mixed_float, self.mixed_int]: - if compat.PY3 and df is self.mixed_frame: + for df in [default_frame, float_string_frame, + mixed_float_frame, mixed_int_frame]: + if compat.PY3 and df is float_string_frame: with pytest.raises(TypeError): df > 0 continue @@ -2631,8 +2631,8 @@ def _check_align(df, cond, other, check_dtypes=True): if check_dtypes and not isinstance(other, np.ndarray): assert (rs.dtypes == df.dtypes).all() - for df in [self.mixed_frame, self.mixed_float, self.mixed_int]: - if compat.PY3 and df is self.mixed_frame: + for df in [float_string_frame, mixed_float_frame, mixed_int_frame]: + if compat.PY3 and df is float_string_frame: with pytest.raises(TypeError): df > 0 continue @@ -2679,9 +2679,9 @@ def _check_set(df, cond, check_dtypes=True): v = np.dtype('float64') assert dfi[k].dtype == v - for df in [default_frame, self.mixed_frame, self.mixed_float, - self.mixed_int]: - if compat.PY3 and df is self.mixed_frame: + for df in [default_frame, float_string_frame, mixed_float_frame, + mixed_int_frame]: + if compat.PY3 and df is float_string_frame: with pytest.raises(TypeError): df > 0 continue @@ -3122,19 +3122,19 @@ def test_mask_callable(self): (df + 2).mask((df + 2) > 8, (df + 2) + 10)) def test_head_tail(self): - assert_frame_equal(self.frame.head(), self.frame[:5]) - assert_frame_equal(self.frame.tail(), self.frame[-5:]) + assert_frame_equal(float_frame.head(), float_frame[:5]) + assert_frame_equal(float_frame.tail(), float_frame[-5:]) - assert_frame_equal(self.frame.head(0), self.frame[0:0]) - assert_frame_equal(self.frame.tail(0), self.frame[0:0]) + assert_frame_equal(float_frame.head(0), float_frame[0:0]) + assert_frame_equal(float_frame.tail(0), float_frame[0:0]) - assert_frame_equal(self.frame.head(-1), self.frame[:-1]) - assert_frame_equal(self.frame.tail(-1), self.frame[1:]) - assert_frame_equal(self.frame.head(1), self.frame[:1]) - assert_frame_equal(self.frame.tail(1), self.frame[-1:]) + assert_frame_equal(float_frame.head(-1), float_frame[:-1]) + assert_frame_equal(float_frame.tail(-1), float_frame[1:]) + assert_frame_equal(float_frame.head(1), float_frame[:1]) + assert_frame_equal(float_frame.tail(1), float_frame[-1:]) # with a float index - df = self.frame.copy() - df.index = np.arange(len(self.frame)) + 0.1 + df = float_frame.copy() + df.index = np.arange(len(float_frame)) + 0.1 assert_frame_equal(df.head(), df.iloc[:5]) assert_frame_equal(df.tail(), df.iloc[-5:]) assert_frame_equal(df.head(0), df[0:0]) diff --git a/pandas/tests/frame/test_missing.py b/pandas/tests/frame/test_missing.py index 136299a4b81be..f4b602b54e55f 100644 --- a/pandas/tests/frame/test_missing.py +++ b/pandas/tests/frame/test_missing.py @@ -42,12 +42,12 @@ def _skip_if_no_pchip(): class TestDataFrameMissingData(TestData): def test_dropEmptyRows(self): - N = len(self.frame.index) + N = len(float_frame.index) mat = random.randn(N) mat[:5] = nan - frame = DataFrame({'foo': mat}, index=self.frame.index) - original = Series(mat, index=self.frame.index, name='foo') + frame = DataFrame({'foo': mat}, index=float_frame.index) + original = Series(mat, index=float_frame.index, name='foo') expected = original.dropna() inplace_frame1, inplace_frame2 = frame.copy(), frame.copy() @@ -64,20 +64,20 @@ def test_dropEmptyRows(self): assert_series_equal(inplace_frame2['foo'], expected) def test_dropIncompleteRows(self): - N = len(self.frame.index) + N = len(float_frame.index) mat = random.randn(N) mat[:5] = nan - frame = DataFrame({'foo': mat}, index=self.frame.index) + frame = DataFrame({'foo': mat}, index=float_frame.index) frame['bar'] = 5 - original = Series(mat, index=self.frame.index, name='foo') + original = Series(mat, index=float_frame.index, name='foo') inp_frame1, inp_frame2 = frame.copy(), frame.copy() smaller_frame = frame.dropna() assert_series_equal(frame['foo'], original) inp_frame1.dropna(inplace=True) - exp = Series(mat[5:], index=self.frame.index[5:], name='foo') + exp = Series(mat[5:], index=float_frame.index[5:], name='foo') tm.assert_series_equal(smaller_frame['foo'], exp) tm.assert_series_equal(inp_frame1['foo'], exp) @@ -85,8 +85,8 @@ def test_dropIncompleteRows(self): assert_series_equal(frame['foo'], original) assert (frame['bar'] == 5).all() inp_frame2.dropna(subset=['bar'], inplace=True) - tm.assert_index_equal(samesize_frame.index, self.frame.index) - tm.assert_index_equal(inp_frame2.index, self.frame.index) + tm.assert_index_equal(samesize_frame.index, float_frame.index) + tm.assert_index_equal(inp_frame2.index, float_frame.index) def test_dropna(self): df = DataFrame(np.random.randn(6, 4)) @@ -163,10 +163,10 @@ def test_drop_and_dropna_caching(self): def test_dropna_corner(self): # bad input - pytest.raises(ValueError, self.frame.dropna, how='foo') - pytest.raises(TypeError, self.frame.dropna, how=None) + pytest.raises(ValueError, float_frame.dropna, how='foo') + pytest.raises(TypeError, float_frame.dropna, how=None) # non-existent column - 8303 - pytest.raises(KeyError, self.frame.dropna, subset=['A', 'X']) + pytest.raises(KeyError, float_frame.dropna, subset=['A', 'X']) def test_dropna_multiple_axes(self): df = DataFrame([[1, np.nan, 2, 3], @@ -212,30 +212,30 @@ def test_dropna_tz_aware_datetime(self): assert_frame_equal(result, expected) def test_fillna(self): - tf = self.tsframe + tf = datetime_frame tf.loc[tf.index[:5], 'A'] = nan tf.loc[tf.index[-5:], 'A'] = nan - zero_filled = self.tsframe.fillna(0) + zero_filled = datetime_frame.fillna(0) assert (zero_filled.loc[zero_filled.index[:5], 'A'] == 0).all() - padded = self.tsframe.fillna(method='pad') + padded = datetime_frame.fillna(method='pad') assert np.isnan(padded.loc[padded.index[:5], 'A']).all() assert (padded.loc[padded.index[-5:], 'A'] == padded.loc[padded.index[-5], 'A']).all() # mixed type - mf = self.mixed_frame + mf = float_string_frame mf.loc[mf.index[5:20], 'foo'] = nan mf.loc[mf.index[-10:], 'A'] = nan - result = self.mixed_frame.fillna(value=0) - result = self.mixed_frame.fillna(method='pad') + result = float_string_frame.fillna(value=0) + result = float_string_frame.fillna(method='pad') - pytest.raises(ValueError, self.tsframe.fillna) - pytest.raises(ValueError, self.tsframe.fillna, 5, method='ffill') + pytest.raises(ValueError, datetime_frame.fillna) + pytest.raises(ValueError, datetime_frame.fillna, 5, method='ffill') # mixed numeric (but no float16) - mf = self.mixed_float.reindex(columns=['A', 'B', 'D']) + mf = mixed_float_frame.reindex(columns=['A', 'B', 'D']) mf.loc[mf.index[-10:], 'A'] = nan result = mf.fillna(value=0) _check_mixed_float(result, dtype=dict(C=None)) @@ -457,18 +457,18 @@ def test_fillna_datetime_columns(self): tm.assert_frame_equal(result, expected) def test_ffill(self): - self.tsframe['A'][:5] = nan - self.tsframe['A'][-5:] = nan + datetime_frame['A'][:5] = nan + datetime_frame['A'][-5:] = nan - assert_frame_equal(self.tsframe.ffill(), - self.tsframe.fillna(method='ffill')) + assert_frame_equal(datetime_frame.ffill(), + datetime_frame.fillna(method='ffill')) def test_bfill(self): - self.tsframe['A'][:5] = nan - self.tsframe['A'][-5:] = nan + datetime_frame['A'][:5] = nan + datetime_frame['A'][-5:] = nan - assert_frame_equal(self.tsframe.bfill(), - self.tsframe.fillna(method='bfill')) + assert_frame_equal(datetime_frame.bfill(), + datetime_frame.fillna(method='bfill')) def test_frame_pad_backfill_limit(self): index = np.arange(10) @@ -597,15 +597,15 @@ def test_fillna_columns(self): def test_fillna_invalid_method(self): with tm.assert_raises_regex(ValueError, 'ffil'): - self.frame.fillna(method='ffil') + float_frame.fillna(method='ffil') def test_fillna_invalid_value(self): # list - pytest.raises(TypeError, self.frame.fillna, [1, 2]) + pytest.raises(TypeError, float_frame.fillna, [1, 2]) # tuple - pytest.raises(TypeError, self.frame.fillna, (1, 2)) + pytest.raises(TypeError, float_frame.fillna, (1, 2)) # frame with series - pytest.raises(TypeError, self.frame.iloc[:, 0].fillna, self.frame) + pytest.raises(TypeError, float_frame.iloc[:, 0].fillna, float_frame) def test_fillna_col_reordering(self): cols = ["COL." + str(i) for i in range(5, 0, -1)] @@ -615,15 +615,15 @@ def test_fillna_col_reordering(self): assert df.columns.tolist() == filled.columns.tolist() def test_fill_corner(self): - mf = self.mixed_frame + mf = float_string_frame mf.loc[mf.index[5:20], 'foo'] = nan mf.loc[mf.index[-10:], 'A'] = nan - filled = self.mixed_frame.fillna(value=0) + filled = float_string_frame.fillna(value=0) assert (filled.loc[filled.index[5:20], 'foo'] == 0).all() - del self.mixed_frame['foo'] + del float_string_frame['foo'] - empty_float = self.frame.reindex(columns=[]) + empty_float = float_frame.reindex(columns=[]) # TODO(wesm): unused? result = empty_float.fillna(value=0) # noqa diff --git a/pandas/tests/frame/test_mutate_columns.py b/pandas/tests/frame/test_mutate_columns.py index 51ffe2966b4e5..8b64d0621b673 100644 --- a/pandas/tests/frame/test_mutate_columns.py +++ b/pandas/tests/frame/test_mutate_columns.py @@ -195,8 +195,8 @@ def test_insert(self): assert_frame_equal(df, exp) def test_delitem(self): - del self.frame['A'] - assert 'A' not in self.frame + del float_frame['A'] + assert 'A' not in float_frame def test_delitem_multiindex(self): midx = MultiIndex.from_product([['A', 'B'], [1, 2]]) @@ -225,15 +225,15 @@ def test_delitem_multiindex(self): del df['A'] def test_pop(self): - self.frame.columns.name = 'baz' + float_frame.columns.name = 'baz' - self.frame.pop('A') - assert 'A' not in self.frame + float_frame.pop('A') + assert 'A' not in float_frame - self.frame['foo'] = 'bar' - self.frame.pop('foo') - assert 'foo' not in self.frame - # TODO assert self.frame.columns.name == 'baz' + float_frame['foo'] = 'bar' + float_frame.pop('foo') + assert 'foo' not in float_frame + # TODO assert float_frame.columns.name == 'baz' # gh-10912: inplace ops cause caching issue a = DataFrame([[1, 2, 3], [4, 5, 6]], columns=[ diff --git a/pandas/tests/frame/test_operators.py b/pandas/tests/frame/test_operators.py index 97c94e1134cc8..a3e57c5497fc6 100644 --- a/pandas/tests/frame/test_operators.py +++ b/pandas/tests/frame/test_operators.py @@ -213,7 +213,7 @@ def _check_unary_op(op): @pytest.mark.filterwarnings("ignore:elementwise:FutureWarning") def test_logical_typeerror_with_non_valid(self, op, res): # we are comparing floats vs a string - result = getattr(self.frame, op)('foo') + result = getattr(float_frame, op)('foo') assert bool(result.all().all()) is res def test_logical_with_nas(self): @@ -267,7 +267,7 @@ def test_neg_raises(self, df): (- df['a']) def test_invert(self): - assert_frame_equal(-(self.frame < 0), ~(self.frame < 0)) + assert_frame_equal(-(float_frame < 0), ~(float_frame < 0)) @pytest.mark.parametrize('df', [ pd.DataFrame({'a': [-1, 1]}), @@ -528,7 +528,7 @@ def test_dti_tz_convert_to_utc(self): assert_frame_equal(df1 + df2, exp) def test_arith_non_pandas_object(self): - df = self.simple + df = simple_frame val1 = df.xs('a').values added = DataFrame(df.values + val1, index=df.index, columns=df.columns) @@ -561,15 +561,15 @@ def test_arith_alignment_non_pandas_object(self, values): assert_frame_equal(result, expected) def test_combineFrame(self): - frame_copy = self.frame.reindex(self.frame.index[::2]) + frame_copy = float_frame.reindex(float_frame.index[::2]) del frame_copy['D'] frame_copy['C'][:5] = nan - added = self.frame + frame_copy + added = float_frame + frame_copy indexer = added['A'].dropna().index - exp = (self.frame['A'] * 2).copy() + exp = (float_frame['A'] * 2).copy() tm.assert_series_equal(added['A'].dropna(), exp.loc[indexer]) @@ -582,95 +582,95 @@ def test_combineFrame(self): assert np.isnan(added['D']).all() - self_added = self.frame + self.frame - tm.assert_index_equal(self_added.index, self.frame.index) + self_added = float_frame + float_frame + tm.assert_index_equal(self_added.index, float_frame.index) - added_rev = frame_copy + self.frame + added_rev = frame_copy + float_frame assert np.isnan(added['D']).all() assert np.isnan(added_rev['D']).all() # corner cases # empty - plus_empty = self.frame + self.empty + plus_empty = float_frame + empty_frame assert np.isnan(plus_empty.values).all() - empty_plus = self.empty + self.frame + empty_plus = empty_frame + float_frame assert np.isnan(empty_plus.values).all() - empty_empty = self.empty + self.empty + empty_empty = empty_frame + empty_frame assert empty_empty.empty # out of order - reverse = self.frame.reindex(columns=self.frame.columns[::-1]) + reverse = float_frame.reindex(columns=float_frame.columns[::-1]) - assert_frame_equal(reverse + self.frame, self.frame * 2) + assert_frame_equal(reverse + float_frame, float_frame * 2) # mix vs float64, upcast - added = self.frame + self.mixed_float + added = float_frame + mixed_float_frame _check_mixed_float(added, dtype='float64') - added = self.mixed_float + self.frame + added = mixed_float_frame + float_frame _check_mixed_float(added, dtype='float64') # mix vs mix - added = self.mixed_float + self.mixed_float2 + added = mixed_float_frame + mixed_float_frame2 _check_mixed_float(added, dtype=dict(C=None)) - added = self.mixed_float2 + self.mixed_float + added = mixed_float_frame2 + mixed_float_frame _check_mixed_float(added, dtype=dict(C=None)) # with int - added = self.frame + self.mixed_int + added = float_frame + mixed_int_frame _check_mixed_float(added, dtype='float64') def test_combineSeries(self): # Series - series = self.frame.xs(self.frame.index[0]) + series = float_frame.xs(float_frame.index[0]) - added = self.frame + series + added = float_frame + series for key, s in compat.iteritems(added): - assert_series_equal(s, self.frame[key] + series[key]) + assert_series_equal(s, float_frame[key] + series[key]) larger_series = series.to_dict() larger_series['E'] = 1 larger_series = Series(larger_series) - larger_added = self.frame + larger_series + larger_added = float_frame + larger_series - for key, s in compat.iteritems(self.frame): + for key, s in compat.iteritems(float_frame): assert_series_equal(larger_added[key], s + series[key]) assert 'E' in larger_added assert np.isnan(larger_added['E']).all() # no upcast needed - added = self.mixed_float + series + added = mixed_float_frame + series _check_mixed_float(added) # vs mix (upcast) as needed - added = self.mixed_float + series.astype('float32') + added = mixed_float_frame + series.astype('float32') _check_mixed_float(added, dtype=dict(C=None)) - added = self.mixed_float + series.astype('float16') + added = mixed_float_frame + series.astype('float16') _check_mixed_float(added, dtype=dict(C=None)) # these raise with numexpr.....as we are adding an int64 to an # uint64....weird vs int - # added = self.mixed_int + (100*series).astype('int64') + # added = mixed_int_frame + (100*series).astype('int64') # _check_mixed_int(added, dtype = dict(A = 'int64', B = 'float64', C = # 'int64', D = 'int64')) - # added = self.mixed_int + (100*series).astype('int32') + # added = mixed_int_frame + (100*series).astype('int32') # _check_mixed_int(added, dtype = dict(A = 'int32', B = 'float64', C = # 'int32', D = 'int64')) # TimeSeries - ts = self.tsframe['A'] + ts = datetime_frame['A'] # 10890 # we no longer allow auto timeseries broadcasting # and require explicit broadcasting - added = self.tsframe.add(ts, axis='index') + added = datetime_frame.add(ts, axis='index') - for key, col in compat.iteritems(self.tsframe): + for key, col in compat.iteritems(datetime_frame): result = col + ts assert_series_equal(added[key], result, check_names=False) assert added[key].name == key @@ -679,52 +679,52 @@ def test_combineSeries(self): else: assert result.name is None - smaller_frame = self.tsframe[:-5] + smaller_frame = datetime_frame[:-5] smaller_added = smaller_frame.add(ts, axis='index') - tm.assert_index_equal(smaller_added.index, self.tsframe.index) + tm.assert_index_equal(smaller_added.index, datetime_frame.index) smaller_ts = ts[:-5] - smaller_added2 = self.tsframe.add(smaller_ts, axis='index') + smaller_added2 = datetime_frame.add(smaller_ts, axis='index') assert_frame_equal(smaller_added, smaller_added2) # length 0, result is all-nan - result = self.tsframe.add(ts[:0], axis='index') - expected = DataFrame(np.nan, index=self.tsframe.index, - columns=self.tsframe.columns) + result = datetime_frame.add(ts[:0], axis='index') + expected = DataFrame(np.nan, index=datetime_frame.index, + columns=datetime_frame.columns) assert_frame_equal(result, expected) # Frame is all-nan - result = self.tsframe[:0].add(ts, axis='index') - expected = DataFrame(np.nan, index=self.tsframe.index, - columns=self.tsframe.columns) + result = datetime_frame[:0].add(ts, axis='index') + expected = DataFrame(np.nan, index=datetime_frame.index, + columns=datetime_frame.columns) assert_frame_equal(result, expected) # empty but with non-empty index - frame = self.tsframe[:1].reindex(columns=[]) + frame = datetime_frame[:1].reindex(columns=[]) result = frame.mul(ts, axis='index') assert len(result) == len(ts) def test_combineFunc(self): - result = self.frame * 2 - tm.assert_numpy_array_equal(result.values, self.frame.values * 2) + result = float_frame * 2 + tm.assert_numpy_array_equal(result.values, float_frame.values * 2) # vs mix - result = self.mixed_float * 2 + result = mixed_float_frame * 2 for c, s in compat.iteritems(result): tm.assert_numpy_array_equal( - s.values, self.mixed_float[c].values * 2) + s.values, mixed_float_frame[c].values * 2) _check_mixed_float(result, dtype=dict(C=None)) - result = self.empty * 2 - assert result.index is self.empty.index + result = empty_frame * 2 + assert result.index is empty_frame.index assert len(result.columns) == 0 def test_comparisons(self): df1 = tm.makeTimeDataFrame() df2 = tm.makeTimeDataFrame() - row = self.simple.xs('a') + row = simple_frame.xs('a') ndim_5 = np.ones(df1.shape + (1, 1, 1)) def test_comp(func): @@ -735,18 +735,18 @@ def test_comp(func): 'Wrong number of dimensions'): func(df1, ndim_5) - result2 = func(self.simple, row) + result2 = func(simple_frame, row) tm.assert_numpy_array_equal(result2.values, - func(self.simple.values, row.values)) + func(simple_frame.values, row.values)) - result3 = func(self.frame, 0) + result3 = func(float_frame, 0) tm.assert_numpy_array_equal(result3.values, - func(self.frame.values, 0)) + func(float_frame.values, 0)) with tm.assert_raises_regex(ValueError, 'Can only compare identically' '-labeled DataFrame'): - func(self.simple, self.simple[:2]) + func(simple_frame, simple_frame[:2]) test_comp(operator.eq) test_comp(operator.ne) @@ -836,8 +836,8 @@ def test_boolean_comparison(self): assert_frame_equal(result, expected) def test_combine_generic(self): - df1 = self.frame - df2 = self.frame.loc[self.frame.index[:-5], ['A', 'B', 'C']] + df1 = float_frame + df2 = float_frame.loc[float_frame.index[:-5], ['A', 'B', 'C']] combined = df1.combine(df2, np.add) combined2 = df2.combine(df1, np.add) @@ -847,7 +847,7 @@ def test_combine_generic(self): chunk = combined.loc[combined.index[:-5], ['A', 'B', 'C']] chunk2 = combined2.loc[combined2.index[:-5], ['A', 'B', 'C']] - exp = self.frame.loc[self.frame.index[:-5], + exp = float_frame.loc[float_frame.index[:-5], ['A', 'B', 'C']].reindex_like(chunk) * 2 assert_frame_equal(chunk, exp) assert_frame_equal(chunk2, exp) diff --git a/pandas/tests/frame/test_quantile.py b/pandas/tests/frame/test_quantile.py index 2f264874378bc..5583c889e83e4 100644 --- a/pandas/tests/frame/test_quantile.py +++ b/pandas/tests/frame/test_quantile.py @@ -21,14 +21,14 @@ class TestDataFrameQuantile(TestData): def test_quantile(self): from numpy import percentile - q = self.tsframe.quantile(0.1, axis=0) - assert q['A'] == percentile(self.tsframe['A'], 10) - tm.assert_index_equal(q.index, self.tsframe.columns) + q = datetime_frame.quantile(0.1, axis=0) + assert q['A'] == percentile(datetime_frame['A'], 10) + tm.assert_index_equal(q.index, datetime_frame.columns) - q = self.tsframe.quantile(0.9, axis=1) + q = datetime_frame.quantile(0.9, axis=1) assert (q['2000-01-17'] == - percentile(self.tsframe.loc['2000-01-17'], 90)) - tm.assert_index_equal(q.index, self.tsframe.index) + percentile(datetime_frame.loc['2000-01-17'], 90)) + tm.assert_index_equal(q.index, datetime_frame.index) # test degenerate case q = DataFrame({'x': [], 'y': []}).quantile(0.1, axis=0) @@ -105,14 +105,14 @@ def test_quantile_interpolation(self): from numpy import percentile # interpolation = linear (default case) - q = self.tsframe.quantile(0.1, axis=0, interpolation='linear') - assert q['A'] == percentile(self.tsframe['A'], 10) - q = self.intframe.quantile(0.1) - assert q['A'] == percentile(self.intframe['A'], 10) + q = datetime_frame.quantile(0.1, axis=0, interpolation='linear') + assert q['A'] == percentile(datetime_frame['A'], 10) + q = int_frame.quantile(0.1) + assert q['A'] == percentile(int_frame['A'], 10) # test with and without interpolation keyword - q1 = self.intframe.quantile(0.1) - assert q1['A'] == np.percentile(self.intframe['A'], 10) + q1 = int_frame.quantile(0.1) + assert q1['A'] == np.percentile(int_frame['A'], 10) tm.assert_series_equal(q, q1) # interpolation method other than default linear @@ -225,7 +225,7 @@ def test_quantile_invalid(self): msg = 'percentiles should all be in the interval \\[0, 1\\]' for invalid in [-1, 2, [0.5, -1], [0.5, 2]]: with tm.assert_raises_regex(ValueError, msg): - self.tsframe.quantile(invalid) + datetime_frame.quantile(invalid) def test_quantile_box(self): df = DataFrame({'A': [pd.Timestamp('2011-01-01'), diff --git a/pandas/tests/frame/test_query_eval.py b/pandas/tests/frame/test_query_eval.py index 3c6f0f0b2ab94..454ebb2f79661 100644 --- a/pandas/tests/frame/test_query_eval.py +++ b/pandas/tests/frame/test_query_eval.py @@ -1019,19 +1019,19 @@ def test_query_string_scalar_variable(self, parser, engine): class TestDataFrameEvalWithFrame(object): def setup_method(self, method): - self.frame = DataFrame(randn(10, 3), columns=list('abc')) + float_frame = DataFrame(randn(10, 3), columns=list('abc')) def teardown_method(self, method): - del self.frame + del float_frame def test_simple_expr(self, parser, engine): - res = self.frame.eval('a + b', engine=engine, parser=parser) - expect = self.frame.a + self.frame.b + res = float_frame.eval('a + b', engine=engine, parser=parser) + expect = float_frame.a + float_frame.b assert_series_equal(res, expect) def test_bool_arith_expr(self, parser, engine): - res = self.frame.eval('a[a < 1] + b', engine=engine, parser=parser) - expect = self.frame.a[self.frame.a < 1] + self.frame.b + res = float_frame.eval('a[a < 1] + b', engine=engine, parser=parser) + expect = float_frame.a[float_frame.a < 1] + float_frame.b assert_series_equal(res, expect) @pytest.mark.parametrize('op', ['+', '-', '*', '/']) diff --git a/pandas/tests/frame/test_rank.py b/pandas/tests/frame/test_rank.py index 3134686c2a2d9..a01f1ef6734ac 100644 --- a/pandas/tests/frame/test_rank.py +++ b/pandas/tests/frame/test_rank.py @@ -35,16 +35,16 @@ def method(self, request): def test_rank(self): rankdata = pytest.importorskip('scipy.stats.rankdata') - self.frame['A'][::2] = np.nan - self.frame['B'][::3] = np.nan - self.frame['C'][::4] = np.nan - self.frame['D'][::5] = np.nan + float_frame['A'][::2] = np.nan + float_frame['B'][::3] = np.nan + float_frame['C'][::4] = np.nan + float_frame['D'][::5] = np.nan - ranks0 = self.frame.rank() - ranks1 = self.frame.rank(1) - mask = np.isnan(self.frame.values) + ranks0 = float_frame.rank() + ranks1 = float_frame.rank(1) + mask = np.isnan(float_frame.values) - fvals = self.frame.fillna(np.inf).values + fvals = float_frame.fillna(np.inf).values exp0 = np.apply_along_axis(rankdata, 0, fvals) exp0[mask] = np.nan @@ -113,11 +113,11 @@ def test_rank2(self): tm.assert_frame_equal(result, expected) # mixed-type frames - self.mixed_frame['datetime'] = datetime.now() - self.mixed_frame['timedelta'] = timedelta(days=1, seconds=1) + float_string_frame['datetime'] = datetime.now() + float_string_frame['timedelta'] = timedelta(days=1, seconds=1) - result = self.mixed_frame.rank(1) - expected = self.mixed_frame.rank(1, numeric_only=True) + result = float_string_frame.rank(1) + expected = float_string_frame.rank(1, numeric_only=True) tm.assert_frame_equal(result, expected) df = DataFrame({"a": [1e-20, -5, 1e-20 + 1e-40, 10, @@ -128,16 +128,16 @@ def test_rank2(self): def test_rank_na_option(self): rankdata = pytest.importorskip('scipy.stats.rankdata') - self.frame['A'][::2] = np.nan - self.frame['B'][::3] = np.nan - self.frame['C'][::4] = np.nan - self.frame['D'][::5] = np.nan + float_frame['A'][::2] = np.nan + float_frame['B'][::3] = np.nan + float_frame['C'][::4] = np.nan + float_frame['D'][::5] = np.nan # bottom - ranks0 = self.frame.rank(na_option='bottom') - ranks1 = self.frame.rank(1, na_option='bottom') + ranks0 = float_frame.rank(na_option='bottom') + ranks1 = float_frame.rank(1, na_option='bottom') - fvals = self.frame.fillna(np.inf).values + fvals = float_frame.fillna(np.inf).values exp0 = np.apply_along_axis(rankdata, 0, fvals) exp1 = np.apply_along_axis(rankdata, 1, fvals) @@ -146,11 +146,11 @@ def test_rank_na_option(self): tm.assert_almost_equal(ranks1.values, exp1) # top - ranks0 = self.frame.rank(na_option='top') - ranks1 = self.frame.rank(1, na_option='top') + ranks0 = float_frame.rank(na_option='top') + ranks1 = float_frame.rank(1, na_option='top') - fval0 = self.frame.fillna((self.frame.min() - 1).to_dict()).values - fval1 = self.frame.T + fval0 = float_frame.fillna((float_frame.min() - 1).to_dict()).values + fval1 = float_frame.T fval1 = fval1.fillna((fval1.min() - 1).to_dict()).T fval1 = fval1.fillna(np.inf).values @@ -163,10 +163,10 @@ def test_rank_na_option(self): # descending # bottom - ranks0 = self.frame.rank(na_option='top', ascending=False) - ranks1 = self.frame.rank(1, na_option='top', ascending=False) + ranks0 = float_frame.rank(na_option='top', ascending=False) + ranks1 = float_frame.rank(1, na_option='top', ascending=False) - fvals = self.frame.fillna(np.inf).values + fvals = float_frame.fillna(np.inf).values exp0 = np.apply_along_axis(rankdata, 0, -fvals) exp1 = np.apply_along_axis(rankdata, 1, -fvals) @@ -177,11 +177,11 @@ def test_rank_na_option(self): # descending # top - ranks0 = self.frame.rank(na_option='bottom', ascending=False) - ranks1 = self.frame.rank(1, na_option='bottom', ascending=False) + ranks0 = float_frame.rank(na_option='bottom', ascending=False) + ranks1 = float_frame.rank(1, na_option='bottom', ascending=False) - fval0 = self.frame.fillna((self.frame.min() - 1).to_dict()).values - fval1 = self.frame.T + fval0 = float_frame.fillna((float_frame.min() - 1).to_dict()).values + fval1 = float_frame.T fval1 = fval1.fillna((fval1.min() - 1).to_dict()).T fval1 = fval1.fillna(np.inf).values @@ -195,11 +195,11 @@ def test_rank_na_option(self): msg = "na_option must be one of 'keep', 'top', or 'bottom'" with tm.assert_raises_regex(ValueError, msg): - self.frame.rank(na_option='bad', ascending=False) + float_frame.rank(na_option='bad', ascending=False) # invalid type with tm.assert_raises_regex(ValueError, msg): - self.frame.rank(na_option=True, ascending=False) + float_frame.rank(na_option=True, ascending=False) def test_rank_axis(self): # check if using axes' names gives the same result diff --git a/pandas/tests/frame/test_replace.py b/pandas/tests/frame/test_replace.py index 49dba1c769572..200e11624d27b 100644 --- a/pandas/tests/frame/test_replace.py +++ b/pandas/tests/frame/test_replace.py @@ -26,25 +26,25 @@ class TestDataFrameReplace(TestData): def test_replace_inplace(self): - self.tsframe['A'][:5] = nan - self.tsframe['A'][-5:] = nan + datetime_frame['A'][:5] = nan + datetime_frame['A'][-5:] = nan - tsframe = self.tsframe.copy() + tsframe = datetime_frame.copy() tsframe.replace(nan, 0, inplace=True) - assert_frame_equal(tsframe, self.tsframe.fillna(0)) + assert_frame_equal(tsframe, datetime_frame.fillna(0)) # mixed type - mf = self.mixed_frame + mf = float_string_frame mf.iloc[5:20, mf.columns.get_loc('foo')] = nan mf.iloc[-10:, mf.columns.get_loc('A')] = nan - result = self.mixed_frame.replace(np.nan, 0) - expected = self.mixed_frame.fillna(value=0) + result = float_string_frame.replace(np.nan, 0) + expected = float_string_frame.fillna(value=0) assert_frame_equal(result, expected) - tsframe = self.tsframe.copy() + tsframe = datetime_frame.copy() tsframe.replace([nan], [0], inplace=True) - assert_frame_equal(tsframe, self.tsframe.fillna(0)) + assert_frame_equal(tsframe, datetime_frame.fillna(0)) def test_regex_replace_scalar(self): obj = {'a': list('ab..'), 'b': list('efgh')} @@ -555,16 +555,16 @@ def test_replace_regex_metachar(self, metachar): assert_frame_equal(result, expected) def test_replace(self): - self.tsframe['A'][:5] = nan - self.tsframe['A'][-5:] = nan + datetime_frame['A'][:5] = nan + datetime_frame['A'][-5:] = nan - zero_filled = self.tsframe.replace(nan, -1e8) - assert_frame_equal(zero_filled, self.tsframe.fillna(-1e8)) - assert_frame_equal(zero_filled.replace(-1e8, nan), self.tsframe) + zero_filled = datetime_frame.replace(nan, -1e8) + assert_frame_equal(zero_filled, datetime_frame.fillna(-1e8)) + assert_frame_equal(zero_filled.replace(-1e8, nan), datetime_frame) - self.tsframe['A'][:5] = nan - self.tsframe['A'][-5:] = nan - self.tsframe['B'][:5] = -1e8 + datetime_frame['A'][:5] = nan + datetime_frame['A'][-5:] = nan + datetime_frame['B'][:5] = -1e8 # empty df = DataFrame(index=['a', 'b']) @@ -649,19 +649,19 @@ def test_replace_convert(self): assert_series_equal(expec, res) def test_replace_mixed(self): - mf = self.mixed_frame + mf = float_string_frame mf.iloc[5:20, mf.columns.get_loc('foo')] = nan mf.iloc[-10:, mf.columns.get_loc('A')] = nan - result = self.mixed_frame.replace(np.nan, -18) - expected = self.mixed_frame.fillna(value=-18) + result = float_string_frame.replace(np.nan, -18) + expected = float_string_frame.fillna(value=-18) assert_frame_equal(result, expected) - assert_frame_equal(result.replace(-18, nan), self.mixed_frame) + assert_frame_equal(result.replace(-18, nan), float_string_frame) - result = self.mixed_frame.replace(np.nan, -1e8) - expected = self.mixed_frame.fillna(value=-1e8) + result = float_string_frame.replace(np.nan, -1e8) + expected = float_string_frame.fillna(value=-1e8) assert_frame_equal(result, expected) - assert_frame_equal(result.replace(-1e8, nan), self.mixed_frame) + assert_frame_equal(result.replace(-1e8, nan), float_string_frame) # int block upcasting df = DataFrame({'A': Series([1.0, 2.0], dtype='float64'), @@ -729,29 +729,29 @@ def test_replace_simple_nested_dict_with_nonexistent_value(self): assert_frame_equal(expected, result) def test_replace_value_is_none(self): - orig_value = self.tsframe.iloc[0, 0] - orig2 = self.tsframe.iloc[1, 0] + orig_value = datetime_frame.iloc[0, 0] + orig2 = datetime_frame.iloc[1, 0] - self.tsframe.iloc[0, 0] = nan - self.tsframe.iloc[1, 0] = 1 + datetime_frame.iloc[0, 0] = nan + datetime_frame.iloc[1, 0] = 1 - result = self.tsframe.replace(to_replace={nan: 0}) - expected = self.tsframe.T.replace(to_replace={nan: 0}).T + result = datetime_frame.replace(to_replace={nan: 0}) + expected = datetime_frame.T.replace(to_replace={nan: 0}).T assert_frame_equal(result, expected) - result = self.tsframe.replace(to_replace={nan: 0, 1: -1e8}) - tsframe = self.tsframe.copy() + result = datetime_frame.replace(to_replace={nan: 0, 1: -1e8}) + tsframe = datetime_frame.copy() tsframe.iloc[0, 0] = 0 tsframe.iloc[1, 0] = -1e8 expected = tsframe assert_frame_equal(expected, result) - self.tsframe.iloc[0, 0] = orig_value - self.tsframe.iloc[1, 0] = orig2 + datetime_frame.iloc[0, 0] = orig_value + datetime_frame.iloc[1, 0] = orig2 def test_replace_for_new_dtypes(self): # dtypes - tsframe = self.tsframe.copy().astype(np.float32) + tsframe = datetime_frame.copy().astype(np.float32) tsframe['A'][:5] = nan tsframe['A'][-5:] = nan diff --git a/pandas/tests/frame/test_repr_info.py b/pandas/tests/frame/test_repr_info.py index 668613c494a47..ae8173f972821 100644 --- a/pandas/tests/frame/test_repr_info.py +++ b/pandas/tests/frame/test_repr_info.py @@ -30,7 +30,7 @@ class TestDataFrameReprInfoEtc(TestData): def test_repr_empty(self): # empty - foo = repr(self.empty) # noqa + foo = repr(empty_frame) # noqa # empty with index frame = DataFrame(index=np.arange(1000)) @@ -40,8 +40,8 @@ def test_repr_mixed(self): buf = StringIO() # mixed - foo = repr(self.mixed_frame) # noqa - self.mixed_frame.info(verbose=False, buf=buf) + foo = repr(float_string_frame) # noqa + float_string_frame.info(verbose=False, buf=buf) @pytest.mark.slow def test_repr_mixed_big(self): @@ -58,12 +58,12 @@ def test_repr(self): buf = StringIO() # small one - foo = repr(self.frame) - self.frame.info(verbose=False, buf=buf) + foo = repr(float_frame) + float_frame.info(verbose=False, buf=buf) # even smaller - self.frame.reindex(columns=['A']).info(verbose=False, buf=buf) - self.frame.reindex(columns=['A', 'B']).info(verbose=False, buf=buf) + float_frame.reindex(columns=['A']).info(verbose=False, buf=buf) + float_frame.reindex(columns=['A', 'B']).info(verbose=False, buf=buf) # exhausting cases in DataFrame.info @@ -72,7 +72,7 @@ def test_repr(self): foo = repr(no_index) # noqa # no columns or index - self.empty.info(buf=buf) + empty_frame.info(buf=buf) df = DataFrame(["a\n\r\tb"], columns=["a\n\r\td"], index=["a\n\r\tf"]) assert "\t" not in repr(df) @@ -113,13 +113,13 @@ def test_repr_unsortable(self): repr(unsortable) fmt.set_option('display.precision', 3, 'display.column_space', 10) - repr(self.frame) + repr(float_frame) fmt.set_option('display.max_rows', 10, 'display.max_columns', 2) - repr(self.frame) + repr(float_frame) fmt.set_option('display.max_rows', 1000, 'display.max_columns', 1000) - repr(self.frame) + repr(float_frame) tm.reset_display_options() @@ -197,8 +197,8 @@ def test_latex_repr(self): @tm.capture_stdout def test_info(self): io = StringIO() - self.frame.info(buf=io) - self.tsframe.info(buf=io) + float_frame.info(buf=io) + datetime_frame.info(buf=io) frame = DataFrame(np.random.randn(5, 3)) diff --git a/pandas/tests/frame/test_reshape.py b/pandas/tests/frame/test_reshape.py index 9f6735c7ba2bf..83ef229e621f3 100644 --- a/pandas/tests/frame/test_reshape.py +++ b/pandas/tests/frame/test_reshape.py @@ -117,7 +117,7 @@ def test_pivot_index_none(self): tm.assert_frame_equal(result, expected) def test_stack_unstack(self): - df = self.frame.copy() + df = float_frame.copy() df[:] = np.arange(np.prod(df.shape)).reshape(df.shape) stacked = df.stack() @@ -485,11 +485,11 @@ def test_unstack_level_binding(self): def test_unstack_to_series(self): # check reversibility - data = self.frame.unstack() + data = float_frame.unstack() assert isinstance(data, Series) undo = data.unstack().T - assert_frame_equal(undo, self.frame) + assert_frame_equal(undo, float_frame) # check NA handling data = DataFrame({'x': [1, 2, np.NaN], 'y': [3.0, 4, np.NaN]}) diff --git a/pandas/tests/frame/test_sorting.py b/pandas/tests/frame/test_sorting.py index 599ae683f914b..96f4a4aafff80 100644 --- a/pandas/tests/frame/test_sorting.py +++ b/pandas/tests/frame/test_sorting.py @@ -276,7 +276,7 @@ def test_sort_datetimes(self): assert_frame_equal(df1, df2) def test_frame_column_inplace_sort_exception(self): - s = self.frame['A'] + s = float_frame['A'] with tm.assert_raises_regex(ValueError, "This Series is a view"): s.sort_values(inplace=True) diff --git a/pandas/tests/frame/test_timeseries.py b/pandas/tests/frame/test_timeseries.py index b1d9d362d1402..2d1cc90a1dfb9 100644 --- a/pandas/tests/frame/test_timeseries.py +++ b/pandas/tests/frame/test_timeseries.py @@ -30,10 +30,10 @@ class TestDataFrameTimeSeriesMethods(TestData): def test_diff(self): - the_diff = self.tsframe.diff(1) + the_diff = datetime_frame.diff(1) assert_series_equal(the_diff['A'], - self.tsframe['A'] - self.tsframe['A'].shift(1)) + datetime_frame['A'] - datetime_frame['A'].shift(1)) # int dtype a = 10000000000000000 @@ -44,7 +44,7 @@ def test_diff(self): assert rs.s[1] == 1 # mixed numeric - tf = self.tsframe.astype('float32') + tf = datetime_frame.astype('float32') the_diff = tf.diff(1) assert_series_equal(the_diff['A'], tf['A'] - tf['A'].shift(1)) @@ -103,13 +103,13 @@ def test_diff_mixed_dtype(self): assert result[0].dtype == np.float64 def test_diff_neg_n(self): - rs = self.tsframe.diff(-1) - xp = self.tsframe - self.tsframe.shift(-1) + rs = datetime_frame.diff(-1) + xp = datetime_frame - datetime_frame.shift(-1) assert_frame_equal(rs, xp) def test_diff_float_n(self): - rs = self.tsframe.diff(1.) - xp = self.tsframe.diff(1) + rs = datetime_frame.diff(1.) + xp = datetime_frame.diff(1) assert_frame_equal(rs, xp) def test_diff_axis(self): @@ -121,19 +121,19 @@ def test_diff_axis(self): [[np.nan, np.nan], [2., 2.]])) def test_pct_change(self): - rs = self.tsframe.pct_change(fill_method=None) - assert_frame_equal(rs, self.tsframe / self.tsframe.shift(1) - 1) + rs = datetime_frame.pct_change(fill_method=None) + assert_frame_equal(rs, datetime_frame / datetime_frame.shift(1) - 1) - rs = self.tsframe.pct_change(2) - filled = self.tsframe.fillna(method='pad') + rs = datetime_frame.pct_change(2) + filled = datetime_frame.fillna(method='pad') assert_frame_equal(rs, filled / filled.shift(2) - 1) - rs = self.tsframe.pct_change(fill_method='bfill', limit=1) - filled = self.tsframe.fillna(method='bfill', limit=1) + rs = datetime_frame.pct_change(fill_method='bfill', limit=1) + filled = datetime_frame.fillna(method='bfill', limit=1) assert_frame_equal(rs, filled / filled.shift(1) - 1) - rs = self.tsframe.pct_change(freq='5D') - filled = self.tsframe.fillna(method='pad') + rs = datetime_frame.pct_change(freq='5D') + filled = datetime_frame.fillna(method='pad') assert_frame_equal(rs, (filled / filled.shift(freq='5D') - 1) .reindex_like(filled)) @@ -157,16 +157,16 @@ def test_pct_change_shift_over_nas(self): ('14B', 14, None, None)]) def test_pct_change_periods_freq(self, freq, periods, fill_method, limit): # GH 7292 - rs_freq = self.tsframe.pct_change(freq=freq, + rs_freq = datetime_frame.pct_change(freq=freq, fill_method=fill_method, limit=limit) - rs_periods = self.tsframe.pct_change(periods, + rs_periods = datetime_frame.pct_change(periods, fill_method=fill_method, limit=limit) assert_frame_equal(rs_freq, rs_periods) - empty_ts = DataFrame(index=self.tsframe.index, - columns=self.tsframe.columns) + empty_ts = DataFrame(index=datetime_frame.index, + columns=datetime_frame.columns) rs_freq = empty_ts.pct_change(freq=freq, fill_method=fill_method, limit=limit) @@ -231,36 +231,36 @@ def test_frame_add_datetime64_col_other_units(self): def test_shift(self): # naive shift - shiftedFrame = self.tsframe.shift(5) - tm.assert_index_equal(shiftedFrame.index, self.tsframe.index) + shiftedFrame = datetime_frame.shift(5) + tm.assert_index_equal(shiftedFrame.index, datetime_frame.index) - shiftedSeries = self.tsframe['A'].shift(5) + shiftedSeries = datetime_frame['A'].shift(5) assert_series_equal(shiftedFrame['A'], shiftedSeries) - shiftedFrame = self.tsframe.shift(-5) - tm.assert_index_equal(shiftedFrame.index, self.tsframe.index) + shiftedFrame = datetime_frame.shift(-5) + tm.assert_index_equal(shiftedFrame.index, datetime_frame.index) - shiftedSeries = self.tsframe['A'].shift(-5) + shiftedSeries = datetime_frame['A'].shift(-5) assert_series_equal(shiftedFrame['A'], shiftedSeries) # shift by 0 - unshifted = self.tsframe.shift(0) - assert_frame_equal(unshifted, self.tsframe) + unshifted = datetime_frame.shift(0) + assert_frame_equal(unshifted, datetime_frame) # shift by DateOffset - shiftedFrame = self.tsframe.shift(5, freq=offsets.BDay()) - assert len(shiftedFrame) == len(self.tsframe) + shiftedFrame = datetime_frame.shift(5, freq=offsets.BDay()) + assert len(shiftedFrame) == len(datetime_frame) - shiftedFrame2 = self.tsframe.shift(5, freq='B') + shiftedFrame2 = datetime_frame.shift(5, freq='B') assert_frame_equal(shiftedFrame, shiftedFrame2) - d = self.tsframe.index[0] + d = datetime_frame.index[0] shifted_d = d + offsets.BDay(5) - assert_series_equal(self.tsframe.xs(d), + assert_series_equal(datetime_frame.xs(d), shiftedFrame.xs(shifted_d), check_names=False) # shift int frame - int_shifted = self.intframe.shift(1) # noqa + int_shifted = int_frame.shift(1) # noqa # Shifting with PeriodIndex ps = tm.makePeriodFrame() @@ -364,32 +364,32 @@ def test_tshift(self): ValueError, 'does not match', ps.tshift, freq='M') # DatetimeIndex - shifted = self.tsframe.tshift(1) + shifted = datetime_frame.tshift(1) unshifted = shifted.tshift(-1) - assert_frame_equal(self.tsframe, unshifted) + assert_frame_equal(datetime_frame, unshifted) - shifted2 = self.tsframe.tshift(freq=self.tsframe.index.freq) + shifted2 = datetime_frame.tshift(freq=datetime_frame.index.freq) assert_frame_equal(shifted, shifted2) - inferred_ts = DataFrame(self.tsframe.values, - Index(np.asarray(self.tsframe.index)), - columns=self.tsframe.columns) + inferred_ts = DataFrame(datetime_frame.values, + Index(np.asarray(datetime_frame.index)), + columns=datetime_frame.columns) shifted = inferred_ts.tshift(1) unshifted = shifted.tshift(-1) - assert_frame_equal(shifted, self.tsframe.tshift(1)) + assert_frame_equal(shifted, datetime_frame.tshift(1)) assert_frame_equal(unshifted, inferred_ts) - no_freq = self.tsframe.iloc[[0, 5, 7], :] + no_freq = datetime_frame.iloc[[0, 5, 7], :] pytest.raises(ValueError, no_freq.tshift) def test_truncate(self): - ts = self.tsframe[::3] + ts = datetime_frame[::3] - start, end = self.tsframe.index[3], self.tsframe.index[6] + start, end = datetime_frame.index[3], datetime_frame.index[6] - start_missing = self.tsframe.index[2] - end_missing = self.tsframe.index[7] + start_missing = datetime_frame.index[2] + end_missing = datetime_frame.index[7] # neither specified truncated = ts.truncate() @@ -427,10 +427,10 @@ def test_truncate(self): after=ts.index[0] + 1) def test_truncate_copy(self): - index = self.tsframe.index - truncated = self.tsframe.truncate(index[5], index[10]) + index = datetime_frame.index + truncated = datetime_frame.truncate(index[5], index[10]) truncated.values[:] = 5. - assert not (self.tsframe.values[5:11] == 5).any() + assert not (datetime_frame.values[5:11] == 5).any() def test_truncate_nonsortedindex(self): # GH 17935 @@ -460,8 +460,8 @@ def test_truncate_nonsortedindex(self): df.truncate(before=2, after=20, axis=1) def test_asfreq(self): - offset_monthly = self.tsframe.asfreq(offsets.BMonthEnd()) - rule_monthly = self.tsframe.asfreq('BM') + offset_monthly = datetime_frame.asfreq(offsets.BMonthEnd()) + rule_monthly = datetime_frame.asfreq('BM') tm.assert_almost_equal(offset_monthly['A'], rule_monthly['A']) @@ -472,7 +472,7 @@ def test_asfreq(self): filled_dep = rule_monthly.asfreq('B', method='pad') # noqa # test does not blow up on length-0 DataFrame - zero_length = self.tsframe.reindex([]) + zero_length = datetime_frame.reindex([]) result = zero_length.asfreq('BM') assert result is not zero_length @@ -515,12 +515,12 @@ def test_asfreq_fillvalue(self): ({'A': [1, np.nan, 3]}, [1, 2, 2], 1, 2)]) def test_first_last_valid(self, data, idx, expected_first, expected_last): - N = len(self.frame.index) + N = len(float_frame.index) mat = randn(N) mat[:5] = nan mat[-5:] = nan - frame = DataFrame({'foo': mat}, index=self.frame.index) + frame = DataFrame({'foo': mat}, index=float_frame.index) index = frame.first_valid_index() assert index == frame.index[5] diff --git a/pandas/tests/frame/test_to_csv.py b/pandas/tests/frame/test_to_csv.py index e1c3c29ef2846..01cca17e72960 100644 --- a/pandas/tests/frame/test_to_csv.py +++ b/pandas/tests/frame/test_to_csv.py @@ -42,36 +42,36 @@ def read_csv(self, path, **kwargs): def test_from_csv_deprecation(self): # see gh-17812 with ensure_clean('__tmp_from_csv_deprecation__') as path: - self.tsframe.to_csv(path) + datetime_frame.to_csv(path) with tm.assert_produces_warning(FutureWarning): depr_recons = DataFrame.from_csv(path) - assert_frame_equal(self.tsframe, depr_recons) + assert_frame_equal(datetime_frame, depr_recons) def test_to_csv_from_csv1(self): with ensure_clean('__tmp_to_csv_from_csv1__') as path: - self.frame['A'][:5] = nan + float_frame['A'][:5] = nan - self.frame.to_csv(path) - self.frame.to_csv(path, columns=['A', 'B']) - self.frame.to_csv(path, header=False) - self.frame.to_csv(path, index=False) + float_frame.to_csv(path) + float_frame.to_csv(path, columns=['A', 'B']) + float_frame.to_csv(path, header=False) + float_frame.to_csv(path, index=False) # test roundtrip - self.tsframe.to_csv(path) + datetime_frame.to_csv(path) recons = self.read_csv(path) - assert_frame_equal(self.tsframe, recons) + assert_frame_equal(datetime_frame, recons) - self.tsframe.to_csv(path, index_label='index') + datetime_frame.to_csv(path, index_label='index') recons = self.read_csv(path, index_col=None) - assert(len(recons.columns) == len(self.tsframe.columns) + 1) + assert(len(recons.columns) == len(datetime_frame.columns) + 1) # no index - self.tsframe.to_csv(path, index=False) + datetime_frame.to_csv(path, index=False) recons = self.read_csv(path, index_col=None) - assert_almost_equal(self.tsframe.values, recons.values) + assert_almost_equal(datetime_frame.values, recons.values) # corner case dm = DataFrame({'s1': Series(lrange(3), lrange(3)), @@ -104,14 +104,14 @@ def test_to_csv_from_csv2(self): # column aliases col_aliases = Index(['AA', 'X', 'Y', 'Z']) - self.frame2.to_csv(path, header=col_aliases) + float_frame2.to_csv(path, header=col_aliases) rs = self.read_csv(path) - xp = self.frame2.copy() + xp = float_frame2.copy() xp.columns = col_aliases assert_frame_equal(xp, rs) - pytest.raises(ValueError, self.frame2.to_csv, path, + pytest.raises(ValueError, float_frame2.to_csv, path, header=['AA', 'X']) def test_to_csv_from_csv3(self): @@ -151,14 +151,14 @@ def test_to_csv_from_csv5(self): # tz, 8260 with ensure_clean('__tmp_to_csv_from_csv5__') as path: - self.tzframe.to_csv(path) + timezone_frame.to_csv(path) result = pd.read_csv(path, index_col=0, parse_dates=['A']) converter = lambda c: to_datetime(result[c]).dt.tz_convert( - 'UTC').dt.tz_convert(self.tzframe[c].dt.tz) + 'UTC').dt.tz_convert(timezone_frame[c].dt.tz) result['B'] = converter('B') result['C'] = converter('C') - assert_frame_equal(result, self.tzframe) + assert_frame_equal(result, timezone_frame) def test_to_csv_cols_reordering(self): # GH3454 @@ -411,32 +411,32 @@ def _to_uni(x): def test_to_csv_from_csv_w_some_infs(self): # test roundtrip with inf, -inf, nan, as full columns and mix - self.frame['G'] = np.nan + float_frame['G'] = np.nan f = lambda x: [np.inf, np.nan][np.random.rand() < .5] - self.frame['H'] = self.frame.index.map(f) + float_frame['H'] = float_frame.index.map(f) with ensure_clean() as path: - self.frame.to_csv(path) + float_frame.to_csv(path) recons = self.read_csv(path) # TODO to_csv drops column name - assert_frame_equal(self.frame, recons, check_names=False) - assert_frame_equal(np.isinf(self.frame), + assert_frame_equal(float_frame, recons, check_names=False) + assert_frame_equal(np.isinf(float_frame), np.isinf(recons), check_names=False) def test_to_csv_from_csv_w_all_infs(self): # test roundtrip with inf, -inf, nan, as full columns and mix - self.frame['E'] = np.inf - self.frame['F'] = -np.inf + float_frame['E'] = np.inf + float_frame['F'] = -np.inf with ensure_clean() as path: - self.frame.to_csv(path) + float_frame.to_csv(path) recons = self.read_csv(path) # TODO to_csv drops column name - assert_frame_equal(self.frame, recons, check_names=False) - assert_frame_equal(np.isinf(self.frame), + assert_frame_equal(float_frame, recons, check_names=False) + assert_frame_equal(np.isinf(float_frame), np.isinf(recons), check_names=False) def test_to_csv_no_index(self): @@ -479,7 +479,7 @@ def test_to_csv_headers(self): def test_to_csv_multiindex(self): - frame = self.frame + frame = float_frame old_index = frame.index arrays = np.arange(len(old_index) * 2).reshape(2, -1) new_index = MultiIndex.from_arrays(arrays, names=['first', 'second']) @@ -501,10 +501,10 @@ def test_to_csv_multiindex(self): assert frame.index.names == df.index.names # needed if setUp becomes a class method - self.frame.index = old_index + float_frame.index = old_index # try multiindex with dates - tsframe = self.tsframe + tsframe = datetime_frame old_index = tsframe.index new_index = [old_index, np.arange(len(old_index))] tsframe.index = MultiIndex.from_arrays(new_index) @@ -523,10 +523,10 @@ def test_to_csv_multiindex(self): # no index tsframe.to_csv(path, index=False) recons = self.read_csv(path, index_col=None) - assert_almost_equal(recons.values, self.tsframe.values) + assert_almost_equal(recons.values, datetime_frame.values) # needed if setUp becomes class method - self.tsframe.index = old_index + datetime_frame.index = old_index with ensure_clean('__tmp_to_csv_multiindex__') as path: # GH3571, GH1651, GH3141 @@ -811,11 +811,11 @@ def test_to_csv_unicode_index_col(self): def test_to_csv_stringio(self): buf = StringIO() - self.frame.to_csv(buf) + float_frame.to_csv(buf) buf.seek(0) recons = read_csv(buf, index_col=0) # TODO to_csv drops column name - assert_frame_equal(recons, self.frame, check_names=False) + assert_frame_equal(recons, float_frame, check_names=False) def test_to_csv_float_format(self): @@ -920,10 +920,10 @@ def test_to_csv_path_is_none(self): # GH 8215 # Make sure we return string for consistency with # Series.to_csv() - csv_str = self.frame.to_csv(path_or_buf=None) + csv_str = float_frame.to_csv(path_or_buf=None) assert isinstance(csv_str, str) recons = pd.read_csv(StringIO(csv_str), index_col=0) - assert_frame_equal(self.frame, recons) + assert_frame_equal(float_frame, recons) @pytest.mark.parametrize('df,encoding', [ (DataFrame([[0.123456, 0.234567, 0.567567], @@ -968,7 +968,7 @@ def test_to_csv_compression(self, df, encoding, compression): def test_to_csv_date_format(self): with ensure_clean('__tmp_to_csv_date_format__') as path: - dt_index = self.tsframe.index + dt_index = datetime_frame.index datetime_frame = DataFrame( {'A': dt_index, 'B': dt_index.shift(1)}, index=dt_index) datetime_frame.to_csv(path, date_format='%Y%m%d')