Fixturize and clean imports for test_arithmetic

Author: h-vetinari

pandas/tests/frame/conftest.py

@@ -82,9 +82,10 @@ def mixed_float_frame():
     Columns are ['A', 'B', 'C', 'D'].
     """
     df = DataFrame(tm.getSeriesData())
-    df.A = df.A.astype('float16')
+    df.A = df.A.astype('float32')
     df.B = df.B.astype('float32')
-    df.C = df.C.astype('float64')
+    df.C = df.C.astype('float16')
+    df.D = df.D.astype('float64')
     return df
 
 
@@ -96,9 +97,10 @@ def mixed_float_frame2():
     Columns are ['A', 'B', 'C', 'D'].
     """
     df = DataFrame(tm.getSeriesData())
-    df.D = df.D.astype('float16')
+    df.D = df.D.astype('float32')
     df.C = df.C.astype('float32')
-    df.B = df.B.astype('float64')
+    df.B = df.B.astype('float16')
+    df.D = df.D.astype('float64')
     return df
 
 
@@ -111,10 +113,10 @@ def mixed_int_frame():
     """
     df = DataFrame({k: v.astype(int)
                    for k, v in compat.iteritems(tm.getSeriesData())})
-    df.A = df.A.astype('uint8')
-    df.B = df.B.astype('int32')
-    df.C = df.C.astype('int64')
-    df.D = np.ones(len(df.D), dtype='uint64')
+    df.A = df.A.astype('int32')
+    df.B = np.ones(len(df.B), dtype='uint64')
+    df.C = df.C.astype('uint8')
+    df.D = df.C.astype('int64')
     return df
 
 

pandas/tests/frame/test_arithmetic.py

@@ -5,9 +5,9 @@
 import numpy as np
 
 from pandas.compat import range, PY3
-import pandas.io.formats.printing as printing
 
-import pandas as pd
+from pandas import (DataFrame, Series, date_range, timedelta_range,
+                    Timedelta, NaT)
 import pandas.util.testing as tm
 
 from pandas.tests.frame.common import _check_mixed_float, _check_mixed_int
@@ -18,29 +18,29 @@
 
 class TestFrameComparisons(object):
     def test_flex_comparison_nat(self):
-        # GH#15697, GH#22163 df.eq(pd.NaT) should behave like df == pd.NaT,
+        # GH 15697, GH 22163 df.eq(NaT) should behave like df == NaT,
         # and _definitely_ not be NaN
-        df = pd.DataFrame([pd.NaT])
+        df = DataFrame([NaT])
 
-        result = df == pd.NaT
+        result = df == NaT
         # result.iloc[0, 0] is a np.bool_ object
         assert result.iloc[0, 0].item() is False
 
-        result = df.eq(pd.NaT)
+        result = df.eq(NaT)
         assert result.iloc[0, 0].item() is False
 
-        result = df != pd.NaT
+        result = df != NaT
         assert result.iloc[0, 0].item() is True
 
-        result = df.ne(pd.NaT)
+        result = df.ne(NaT)
         assert result.iloc[0, 0].item() is True
 
     def test_mixed_comparison(self):
-        # GH#13128, GH#22163 != datetime64 vs non-dt64 should be False,
+        # GH 13128, GH 22163 != datetime64 vs non-dt64 should be False,
         # not raise TypeError
         # (this appears to be fixed before #22163, not sure when)
-        df = pd.DataFrame([['1989-08-01', 1], ['1989-08-01', 2]])
-        other = pd.DataFrame([['a', 'b'], ['c', 'd']])
+        df = DataFrame([['1989-08-01', 1], ['1989-08-01', 2]])
+        other = DataFrame([['a', 'b'], ['c', 'd']])
 
         result = df == other
         assert not result.any().any()
@@ -49,9 +49,9 @@ def test_mixed_comparison(self):
         assert result.all().all()
 
     def test_df_boolean_comparison_error(self):
-        # GH#4576
+        # GH 4576
         # boolean comparisons with a tuple/list give unexpected results
-        df = pd.DataFrame(np.arange(6).reshape((3, 2)))
+        df = DataFrame(np.arange(6).reshape((3, 2)))
 
         # not shape compatible
         with pytest.raises(ValueError):
@@ -60,14 +60,14 @@ def test_df_boolean_comparison_error(self):
             df == [2, 2]
 
     def test_df_float_none_comparison(self):
-        df = pd.DataFrame(np.random.randn(8, 3), index=range(8),
-                          columns=['A', 'B', 'C'])
+        df = DataFrame(np.random.randn(8, 3), index=range(8),
+                       columns=['A', 'B', 'C'])
 
         result = df.__eq__(None)
         assert not result.any().any()
 
     def test_df_string_comparison(self):
-        df = pd.DataFrame([{"a": 1, "b": "foo"}, {"a": 2, "b": "bar"}])
+        df = DataFrame([{"a": 1, "b": "foo"}, {"a": 2, "b": "bar"}])
         mask_a = df.a > 1
         tm.assert_frame_equal(df[mask_a], df.loc[1:1, :])
         tm.assert_frame_equal(df[-mask_a], df.loc[0:0, :])
@@ -78,181 +78,145 @@ def test_df_string_comparison(self):
 
     @pytest.mark.parametrize('opname', ['eq', 'ne', 'gt', 'lt', 'ge', 'le'])
     def test_df_flex_cmp_constant_return_types(self, opname):
-        # GH#15077, non-empty DataFrame
-        df = pd.DataFrame({'x': [1, 2, 3], 'y': [1., 2., 3.]})
+        # GH 15077, non-empty DataFrame
+        df = DataFrame({'x': [1, 2, 3], 'y': [1., 2., 3.]})
         const = 2
 
         result = getattr(df, opname)(const).get_dtype_counts()
-        tm.assert_series_equal(result, pd.Series([2], ['bool']))
+        tm.assert_series_equal(result, Series([2], ['bool']))
 
     @pytest.mark.parametrize('opname', ['eq', 'ne', 'gt', 'lt', 'ge', 'le'])
     def test_df_flex_cmp_constant_return_types_empty(self, opname):
-        # GH#15077 empty DataFrame
-        df = pd.DataFrame({'x': [1, 2, 3], 'y': [1., 2., 3.]})
+        # GH 15077 empty DataFrame
+        df = DataFrame({'x': [1, 2, 3], 'y': [1., 2., 3.]})
         const = 2
 
         empty = df.iloc[:0]
         result = getattr(empty, opname)(const).get_dtype_counts()
-        tm.assert_series_equal(result, pd.Series([2], ['bool']))
+        tm.assert_series_equal(result, Series([2], ['bool']))
 
 
 # -------------------------------------------------------------------
 # Arithmetic
 
 class TestFrameFlexArithmetic(object):
     def test_df_add_td64_columnwise(self):
-        # GH#22534 Check that column-wise addition broadcasts correctly
-        dti = pd.date_range('2016-01-01', periods=10)
-        tdi = pd.timedelta_range('1', periods=10)
-        tser = pd.Series(tdi)
-        df = pd.DataFrame({0: dti, 1: tdi})
+        # GH 22534 Check that column-wise addition broadcasts correctly
+        dti = date_range('2016-01-01', periods=10)
+        tdi = timedelta_range('1', periods=10)
+        tser = Series(tdi)
+        df = DataFrame({0: dti, 1: tdi})
 
         result = df.add(tser, axis=0)
-        expected = pd.DataFrame({0: dti + tdi,
-                                 1: tdi + tdi})
+        expected = DataFrame({0: dti + tdi, 1: tdi + tdi})
         tm.assert_frame_equal(result, expected)
 
     def test_df_add_flex_filled_mixed_dtypes(self):
-        # GH#19611
-        dti = pd.date_range('2016-01-01', periods=3)
-        ser = pd.Series(['1 Day', 'NaT', '2 Days'], dtype='timedelta64[ns]')
-        df = pd.DataFrame({'A': dti, 'B': ser})
-        other = pd.DataFrame({'A': ser, 'B': ser})
-        fill = pd.Timedelta(days=1).to_timedelta64()
+        # GH 19611
+        dti = date_range('2016-01-01', periods=3)
+        ser = Series(['1 Day', 'NaT', '2 Days'], dtype='timedelta64[ns]')
+        df = DataFrame({'A': dti, 'B': ser})
+        other = DataFrame({'A': ser, 'B': ser})
+        fill = Timedelta(days=1).to_timedelta64()
         result = df.add(other, fill_value=fill)
 
-        expected = pd.DataFrame(
-            {'A': pd.Series(['2016-01-02', '2016-01-03', '2016-01-05'],
-                            dtype='datetime64[ns]'),
+        expected = DataFrame(
+            {'A': Series(['2016-01-02', '2016-01-03', '2016-01-05'],
+                         dtype='datetime64[ns]'),
              'B': ser * 2})
         tm.assert_frame_equal(result, expected)
 
-    def test_arith_flex_frame(self):
-        seriesd = tm.getSeriesData()
-        frame = pd.DataFrame(seriesd).copy()
+    @pytest.mark.parametrize('op', ['add', 'sub', 'mul', 'div', 'truediv',
+                                    'pow', 'floordiv', 'mod'])
+    def test_arith_flex_frame(self, op, int_frame, mixed_int_frame,
+                              float_frame, mixed_float_frame):
 
-        mixed_float = pd.DataFrame({'A': frame['A'].copy().astype('float32'),
-                                    'B': frame['B'].copy().astype('float32'),
-                                    'C': frame['C'].copy().astype('float16'),
-                                    'D': frame['D'].copy().astype('float64')})
-
-        intframe = pd.DataFrame({k: v.astype(int)
-                                 for k, v in seriesd.items()})
-        mixed_int = pd.DataFrame({'A': intframe['A'].copy().astype('int32'),
-                                  'B': np.ones(len(intframe), dtype='uint64'),
-                                  'C': intframe['C'].copy().astype('uint8'),
-                                  'D': intframe['D'].copy().astype('int64')})
-
-        # force these all to int64 to avoid platform testing issues
-        intframe = pd.DataFrame({c: s for c, s in intframe.items()},
-                                dtype=np.int64)
-
-        ops = ['add', 'sub', 'mul', 'div', 'truediv', 'pow', 'floordiv', 'mod']
         if not PY3:
             aliases = {}
         else:
             aliases = {'div': 'truediv'}
-
-        for op in ops:
-            try:
-                alias = aliases.get(op, op)
-                f = getattr(operator, alias)
-                result = getattr(frame, op)(2 * frame)
-                exp = f(frame, 2 * frame)
+        alias = aliases.get(op, op)
+
+        f = getattr(operator, alias)
+        result = getattr(float_frame, op)(2 * float_frame)
+        exp = f(float_frame, 2 * float_frame)
+        tm.assert_frame_equal(result, exp)
+
+        # vs mix float
+        result = getattr(mixed_float_frame, op)(2 * mixed_float_frame)
+        exp = f(mixed_float_frame, 2 * mixed_float_frame)
+        tm.assert_frame_equal(result, exp)
+        _check_mixed_float(result, dtype=dict(C=None))
+
+        # vs mix int
+        if op in ['add', 'sub', 'mul']:
+            result = getattr(mixed_int_frame, op)(2 + mixed_int_frame)
+            exp = f(mixed_int_frame, 2 + mixed_int_frame)
+
+            # no overflow in the uint
+            dtype = None
+            if op in ['sub']:
+                dtype = dict(B='uint64', C=None)
+            elif op in ['add', 'mul']:
+                dtype = dict(C=None)
+            tm.assert_frame_equal(result, exp)
+            _check_mixed_int(result, dtype=dtype)
+
+            # rops
+            r_f = lambda x, y: f(y, x)
+            result = getattr(float_frame, 'r' + op)(2 * float_frame)
+            exp = r_f(float_frame, 2 * float_frame)
+            tm.assert_frame_equal(result, exp)
+
+            # vs mix float
+            result = getattr(mixed_float_frame, op)(2 * mixed_float_frame)
+            exp = f(mixed_float_frame, 2 * mixed_float_frame)
+            tm.assert_frame_equal(result, exp)
+            _check_mixed_float(result, dtype=dict(C=None))
+
+            result = getattr(int_frame, op)(2 * int_frame)
+            exp = f(int_frame, 2 * int_frame)
+            tm.assert_frame_equal(result, exp)
+
+            # vs mix int
+            if op in ['add', 'sub', 'mul']:
+                result = getattr(mixed_int_frame, op)(2 + mixed_int_frame)
+                exp = f(mixed_int_frame, 2 + mixed_int_frame)
+
+                # no overflow in the uint
+                dtype = None
+                if op in ['sub']:
+                    dtype = dict(B='uint64', C=None)
+                elif op in ['add', 'mul']:
+                    dtype = dict(C=None)
                 tm.assert_frame_equal(result, exp)
+                _check_mixed_int(result, dtype=dtype)
 
-                # vs mix float
-                result = getattr(mixed_float, op)(2 * mixed_float)
-                exp = f(mixed_float, 2 * mixed_float)
-                tm.assert_frame_equal(result, exp)
-                _check_mixed_float(result, dtype=dict(C=None))
-
-                # vs mix int
-                if op in ['add', 'sub', 'mul']:
-                    result = getattr(mixed_int, op)(2 + mixed_int)
-                    exp = f(mixed_int, 2 + mixed_int)
-
-                    # no overflow in the uint
-                    dtype = None
-                    if op in ['sub']:
-                        dtype = dict(B='uint64', C=None)
-                    elif op in ['add', 'mul']:
-                        dtype = dict(C=None)
-                    tm.assert_frame_equal(result, exp)
-                    _check_mixed_int(result, dtype=dtype)
-
-                    # rops
-                    r_f = lambda x, y: f(y, x)
-                    result = getattr(frame, 'r' + op)(2 * frame)
-                    exp = r_f(frame, 2 * frame)
-                    tm.assert_frame_equal(result, exp)
-
-                    # vs mix float
-                    result = getattr(mixed_float, op)(2 * mixed_float)
-                    exp = f(mixed_float, 2 * mixed_float)
-                    tm.assert_frame_equal(result, exp)
-                    _check_mixed_float(result, dtype=dict(C=None))
-
-                    result = getattr(intframe, op)(2 * intframe)
-                    exp = f(intframe, 2 * intframe)
-                    tm.assert_frame_equal(result, exp)
-
-                    # vs mix int
-                    if op in ['add', 'sub', 'mul']:
-                        result = getattr(mixed_int, op)(2 + mixed_int)
-                        exp = f(mixed_int, 2 + mixed_int)
-
-                        # no overflow in the uint
-                        dtype = None
-                        if op in ['sub']:
-                            dtype = dict(B='uint64', C=None)
-                        elif op in ['add', 'mul']:
-                            dtype = dict(C=None)
-                        tm.assert_frame_equal(result, exp)
-                        _check_mixed_int(result, dtype=dtype)
-            except:
-                printing.pprint_thing("Failing operation %r" % op)
-                raise
-
-            # ndim >= 3
-            ndim_5 = np.ones(frame.shape + (3, 4, 5))
-            msg = "Unable to coerce to Series/DataFrame"
-            with tm.assert_raises_regex(ValueError, msg):
-                f(frame, ndim_5)
-
-            with tm.assert_raises_regex(ValueError, msg):
-                getattr(frame, op)(ndim_5)
-
-        # res_add = frame.add(frame)
-        # res_sub = frame.sub(frame)
-        # res_mul = frame.mul(frame)
-        # res_div = frame.div(2 * frame)
-
-        # tm.assert_frame_equal(res_add, frame + frame)
-        # tm.assert_frame_equal(res_sub, frame - frame)
-        # tm.assert_frame_equal(res_mul, frame * frame)
-        # tm.assert_frame_equal(res_div, frame / (2 * frame))
-
-        const_add = frame.add(1)
-        tm.assert_frame_equal(const_add, frame + 1)
+        # ndim >= 3
+        ndim_5 = np.ones(float_frame.shape + (3, 4, 5))
+        msg = "Unable to coerce to Series/DataFrame"
+        with tm.assert_raises_regex(ValueError, msg):
+            f(float_frame, ndim_5)
+
+        with tm.assert_raises_regex(ValueError, msg):
+            getattr(float_frame, op)(ndim_5)
+
+        const_add = float_frame.add(1)
+        tm.assert_frame_equal(const_add, float_frame + 1)
 
         # corner cases
-        result = frame.add(frame[:0])
-        tm.assert_frame_equal(result, frame * np.nan)
+        result = float_frame.add(float_frame[:0])
+        tm.assert_frame_equal(result, float_frame * np.nan)
 
-        result = frame[:0].add(frame)
-        tm.assert_frame_equal(result, frame * np.nan)
+        result = float_frame[:0].add(float_frame)
+        tm.assert_frame_equal(result, float_frame * np.nan)
         with tm.assert_raises_regex(NotImplementedError, 'fill_value'):
-            frame.add(frame.iloc[0], fill_value=3)
+            float_frame.add(float_frame.iloc[0], fill_value=3)
         with tm.assert_raises_regex(NotImplementedError, 'fill_value'):
-            frame.add(frame.iloc[0], axis='index', fill_value=3)
+            float_frame.add(float_frame.iloc[0], axis='index', fill_value=3)
 
-    def test_arith_flex_series(self):
-        arr = np.array([[1., 2., 3.],
-                        [4., 5., 6.],
-                        [7., 8., 9.]])
-        df = pd.DataFrame(arr, columns=['one', 'two', 'three'],
-                          index=['a', 'b', 'c'])
+    def test_arith_flex_series(self, simple_frame):
+        df = simple_frame
 
         row = df.xs('a')
         col = df['two']
@@ -271,23 +235,23 @@ def test_arith_flex_series(self):
         tm.assert_frame_equal(df.div(row), df / row)
         tm.assert_frame_equal(df.div(col, axis=0), (df.T / col).T)
 
-        # broadcasting issue in GH#7325
-        df = pd.DataFrame(np.arange(3 * 2).reshape((3, 2)), dtype='int64')
-        expected = pd.DataFrame([[np.nan, np.inf], [1.0, 1.5], [1.0, 1.25]])
+        # broadcasting issue in GH 7325
+        df = DataFrame(np.arange(3 * 2).reshape((3, 2)), dtype='int64')
+        expected = DataFrame([[np.nan, np.inf], [1.0, 1.5], [1.0, 1.25]])
         result = df.div(df[0], axis='index')
         tm.assert_frame_equal(result, expected)
 
-        df = pd.DataFrame(np.arange(3 * 2).reshape((3, 2)), dtype='float64')
-        expected = pd.DataFrame([[np.nan, np.inf], [1.0, 1.5], [1.0, 1.25]])
+        df = DataFrame(np.arange(3 * 2).reshape((3, 2)), dtype='float64')
+        expected = DataFrame([[np.nan, np.inf], [1.0, 1.5], [1.0, 1.25]])
         result = df.div(df[0], axis='index')
         tm.assert_frame_equal(result, expected)
 
     def test_arith_flex_zero_len_raises(self):
-        # GH#19522 passing fill_value to frame flex arith methods should
+        # GH 19522 passing fill_value to frame flex arith methods should
         # raise even in the zero-length special cases
-        ser_len0 = pd.Series([])
-        df_len0 = pd.DataFrame([], columns=['A', 'B'])
-        df = pd.DataFrame([[1, 2], [3, 4]], columns=['A', 'B'])
+        ser_len0 = Series([])
+        df_len0 = DataFrame([], columns=['A', 'B'])
+        df = DataFrame([[1, 2], [3, 4]], columns=['A', 'B'])
 
         with tm.assert_raises_regex(NotImplementedError, 'fill_value'):
             df.add(ser_len0, fill_value='E')
@@ -298,9 +262,9 @@ def test_arith_flex_zero_len_raises(self):
 
 class TestFrameArithmetic(object):
     def test_df_bool_mul_int(self):
-        # GH#22047, GH#22163 multiplication by 1 should result in int dtype,
+        # GH 22047, GH 22163 multiplication by 1 should result in int dtype,
         # not object dtype
-        df = pd.DataFrame([[False, True], [False, False]])
+        df = DataFrame([[False, True], [False, False]])
         result = df * 1
 
         # On appveyor this comes back as np.int32 instead of np.int64,