TST/CLN: empty DataFrames and some 'empty' Series

pandas/tests/frame/test_arithmetic.py

@@ -437,7 +437,7 @@ def test_arith_flex_zero_len_raises(self):
         # 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_len0 = pd.DataFrame(columns=['A', 'B'])
         df = pd.DataFrame([[1, 2], [3, 4]], columns=['A', 'B'])
 
         with pytest.raises(NotImplementedError, match='fill_value'):

pandas/tests/frame/test_combine_concat.py

@@ -172,8 +172,8 @@ def test_append_list_of_series_dicts(self):
     def test_append_empty_dataframe(self):
 
         # Empty df append empty df
-        df1 = DataFrame([])
-        df2 = DataFrame([])
+        df1 = DataFrame()
+        df2 = DataFrame()
         result = df1.append(df2)
         expected = df1.copy()
         assert_frame_equal(result, expected)
@@ -576,18 +576,18 @@ def test_combine_first(self, float_frame):
         assert_series_equal(combined['A'].reindex(g.index), g['A'])
 
         # corner cases
-        comb = float_frame.combine_first(DataFrame({}))
+        comb = float_frame.combine_first(DataFrame())
         assert_frame_equal(comb, float_frame)
 
-        comb = DataFrame({}).combine_first(float_frame)
+        comb = DataFrame().combine_first(float_frame)
         assert_frame_equal(comb, float_frame)
 
         comb = float_frame.combine_first(DataFrame(index=["faz", "boo"]))
         assert "faz" in comb.index
 
         # #2525
         df = DataFrame({'a': [1]}, index=[datetime(2012, 1, 1)])
-        df2 = DataFrame({}, columns=['b'])
+        df2 = DataFrame(columns=['b'])
         result = df.combine_first(df2)
         assert 'b' in result
 

pandas/tests/frame/test_constructors.py

@@ -32,12 +32,33 @@
 
 class TestDataFrameConstructors(TestData):
 
-    def test_constructor(self):
-        df = DataFrame()
-        assert len(df.index) == 0
-
-        df = DataFrame(data={})
-        assert len(df.index) == 0
+    @pytest.mark.parametrize('constructor', [
+        lambda: DataFrame(),
+        lambda: DataFrame(None),
+        lambda: DataFrame({}),
+        lambda: DataFrame(()),
+        lambda: DataFrame([]),
+        lambda: DataFrame((x for x in [])),
+        lambda: DataFrame(data=None),
+        lambda: DataFrame(data={}),
+        lambda: DataFrame(data=()),
+        lambda: DataFrame(data=[]),
+        lambda: DataFrame(data=(x for x in [])),
+        # these are NOT empty DataFrames
+        pytest.param(lambda: DataFrame([[]]), marks=pytest.mark.xfail(
+            reason='creates a non-zero length RangeIndex')),
+        pytest.param(lambda: DataFrame([[], []]), marks=pytest.mark.xfail(
+            reason='creates a non-zero length RangeIndex')),
+        pytest.param(lambda: DataFrame([(x for x in [])]),
+                     marks=pytest.mark.xfail(
+            reason='creates a non-zero length RangeIndex'))
+    ])
+    def test_empty_constructor(self, constructor):
+        expected = DataFrame()
+        result = constructor()
+        assert len(result.index) == 0
+        assert len(result.columns) == 0
+        tm.assert_frame_equal(result, expected)
 
     def test_constructor_mixed(self):
         index, data = tm.getMixedTypeDict()
@@ -95,7 +116,7 @@ def test_constructor_dtype_list_data(self):
 
     def test_constructor_list_frames(self):
         # see gh-3243
-        result = DataFrame([DataFrame([])])
+        result = DataFrame([DataFrame()])
         assert result.shape == (1, 0)
 
         result = DataFrame([DataFrame(dict(A=lrange(5)))])
@@ -265,7 +286,7 @@ def test_constructor_dict(self):
         frame = DataFrame({}, index=idx)
         assert frame.index is idx
 
-        # empty with index and columns
+        # empty dict with index and columns
         idx = Index([0, 1, 2])
         frame = DataFrame({}, index=idx, columns=idx)
         assert frame.index is idx
@@ -1122,7 +1143,7 @@ def test_constructor_list_of_series(self):
         result2 = DataFrame(data, index=np.arange(6))
         tm.assert_frame_equal(result, result2)
 
-        result = DataFrame([Series({})])
+        result = DataFrame([Series()])
         expected = DataFrame(index=[0])
         tm.assert_frame_equal(result, expected)
 

pandas/tests/frame/test_reshape.py

@@ -56,7 +56,7 @@ def test_pivot_duplicates(self):
             data.pivot('a', 'b', 'c')
 
     def test_pivot_empty(self):
-        df = DataFrame({}, columns=['a', 'b', 'c'])
+        df = DataFrame(columns=['a', 'b', 'c'])
         result = df.pivot('a', 'b', 'c')
         expected = DataFrame()
         tm.assert_frame_equal(result, expected, check_names=False)

pandas/tests/groupby/test_function.py

@@ -1064,8 +1064,8 @@ def test_size(df):
         tm.assert_series_equal(left, right, check_names=False)
 
     # GH11699
-    df = DataFrame([], columns=['A', 'B'])
-    out = Series([], dtype='int64', index=Index([], name='A'))
+    df = DataFrame(columns=['A', 'B'])
+    out = Series(dtype='int64', index=Index([], name='A'))
     tm.assert_series_equal(df.groupby('A').size(), out)
 
 

pandas/tests/groupby/test_groupby.py

@@ -298,7 +298,7 @@ def f1(x):
         if y.empty:
             multiindex = MultiIndex(levels=[[]] * 2, codes=[[]] * 2,
                                     names=['b', 'c'])
-            res = DataFrame(None, columns=['a'], index=multiindex)
+            res = DataFrame(columns=['a'], index=multiindex)
             return res
         else:
             y = y.set_index(['b', 'c'])
@@ -317,7 +317,7 @@ def f3(x):
         if y.empty:
             multiindex = MultiIndex(levels=[[]] * 2, codes=[[]] * 2,
                                     names=['foo', 'bar'])
-            res = DataFrame(None, columns=['a', 'b'], index=multiindex)
+            res = DataFrame(columns=['a', 'b'], index=multiindex)
             return res
         else:
             return y

pandas/tests/groupby/test_grouping.py

@@ -643,7 +643,7 @@ def test_groupby_with_single_column(self):
         df = pd.DataFrame({'a': list('abssbab')})
         tm.assert_frame_equal(df.groupby('a').get_group('a'), df.iloc[[0, 5]])
         # GH 13530
-        exp = pd.DataFrame([], index=pd.Index(['a', 'b', 's'], name='a'))
+        exp = pd.DataFrame(index=pd.Index(['a', 'b', 's'], name='a'))
         tm.assert_frame_equal(df.groupby('a').count(), exp)
         tm.assert_frame_equal(df.groupby('a').sum(), exp)
         tm.assert_frame_equal(df.groupby('a').nth(1), exp)

pandas/tests/indexing/common.py

@@ -85,8 +85,8 @@ def setup_method(self, method):
         self.frame_ts_rev = DataFrame(np.random.randn(4, 4),
                                       index=dates_rev)
 
-        self.frame_empty = DataFrame({})
-        self.series_empty = Series({})
+        self.frame_empty = DataFrame()
+        self.series_empty = Series()
 
         # form agglomerates
         for o in self._objs:

pandas/tests/io/json/test_json_table_schema.py

@@ -459,7 +459,7 @@ def test_set_names_unset(self, idx, nm, prop):
     ])
     def test_warns_non_roundtrippable_names(self, idx):
         # GH 19130
-        df = pd.DataFrame([[]], index=idx)
+        df = pd.DataFrame(index=idx)
         df.index.name = 'index'
         with tm.assert_produces_warning():
             set_default_names(df)
@@ -566,7 +566,7 @@ def test_multiindex(self, index_names):
 
     def test_empty_frame_roundtrip(self):
         # GH 21287
-        df = pd.DataFrame([], columns=['a', 'b', 'c'])
+        df = pd.DataFrame(columns=['a', 'b', 'c'])
         expected = df.copy()
         out = df.to_json(orient='table')
         result = pd.read_json(out, orient='table')

pandas/tests/io/json/test_pandas.py

@@ -54,7 +54,7 @@ def setup(self, datapath):
         self.objSeries.name = 'objects'
 
         self.empty_series = Series([], index=[])
-        self.empty_frame = DataFrame({})
+        self.empty_frame = DataFrame()
 
         self.frame = _frame.copy()
         self.frame2 = _frame2.copy()

pandas/tests/io/parser/test_common.py

@@ -1151,7 +1151,7 @@ def test_empty_with_index(all_parsers):
     parser = all_parsers
     result = parser.read_csv(StringIO(data), index_col=0)
 
-    expected = DataFrame([], columns=["y"], index=Index([], name="x"))
+    expected = DataFrame(columns=["y"], index=Index([], name="x"))
     tm.assert_frame_equal(result, expected)
 
 
@@ -1161,7 +1161,7 @@ def test_empty_with_multi_index(all_parsers):
     parser = all_parsers
     result = parser.read_csv(StringIO(data), index_col=["x", "y"])
 
-    expected = DataFrame([], columns=["z"],
+    expected = DataFrame(columns=["z"],
                          index=MultiIndex.from_arrays(
                              [[]] * 2, names=["x", "y"]))
     tm.assert_frame_equal(result, expected)
@@ -1172,7 +1172,7 @@ def test_empty_with_reversed_multi_index(all_parsers):
     parser = all_parsers
     result = parser.read_csv(StringIO(data), index_col=[1, 0])
 
-    expected = DataFrame([], columns=["z"],
+    expected = DataFrame(columns=["z"],
                          index=MultiIndex.from_arrays(
                              [[]] * 2, names=["y", "x"]))
     tm.assert_frame_equal(result, expected)
@@ -1284,7 +1284,7 @@ def test_numeric_range_too_wide(all_parsers, exp_data):
 def test_empty_with_nrows_chunksize(all_parsers, iterator):
     # see gh-9535
     parser = all_parsers
-    expected = DataFrame([], columns=["foo", "bar"])
+    expected = DataFrame(columns=["foo", "bar"])
 
     nrows = 10
     data = StringIO("foo,bar\n")

pandas/tests/io/parser/test_index_col.py

@@ -105,7 +105,7 @@ def test_index_col_empty_data(all_parsers, index_col, kwargs):
     parser = all_parsers
     result = parser.read_csv(StringIO(data), index_col=index_col)
 
-    expected = DataFrame([], **kwargs)
+    expected = DataFrame(**kwargs)
     tm.assert_frame_equal(result, expected)
 
 
@@ -115,7 +115,7 @@ def test_empty_with_index_col_false(all_parsers):
     parser = all_parsers
     result = parser.read_csv(StringIO(data), index_col=False)
 
-    expected = DataFrame([], columns=["x", "y"])
+    expected = DataFrame(columns=["x", "y"])
     tm.assert_frame_equal(result, expected)
 
 

pandas/tests/resample/test_period_index.py

@@ -715,7 +715,7 @@ def test_resample_with_only_nat(self):
         pi = PeriodIndex([pd.NaT] * 3, freq='S')
         frame = DataFrame([2, 3, 5], index=pi)
         expected_index = PeriodIndex(data=[], freq=pi.freq)
-        expected = DataFrame([], index=expected_index)
+        expected = DataFrame(index=expected_index)
         result = frame.resample('1s').mean()
         assert_frame_equal(result, expected)
 

pandas/tests/reshape/merge/test_merge.py

@@ -386,10 +386,10 @@ def test_left_merge_empty_dataframe(self):
                               dict(left_on='a', right_on='x')])
     def test_merge_left_empty_right_empty(self, join_type, kwarg):
         # GH 10824
-        left = pd.DataFrame([], columns=['a', 'b', 'c'])
-        right = pd.DataFrame([], columns=['x', 'y', 'z'])
+        left = pd.DataFrame(columns=['a', 'b', 'c'])
+        right = pd.DataFrame(columns=['x', 'y', 'z'])
 
-        exp_in = pd.DataFrame([], columns=['a', 'b', 'c', 'x', 'y', 'z'],
+        exp_in = pd.DataFrame(columns=['a', 'b', 'c', 'x', 'y', 'z'],
                               index=pd.Index([], dtype=object),
                               dtype=object)
 
@@ -398,7 +398,7 @@ def test_merge_left_empty_right_empty(self, join_type, kwarg):
 
     def test_merge_left_empty_right_notempty(self):
         # GH 10824
-        left = pd.DataFrame([], columns=['a', 'b', 'c'])
+        left = pd.DataFrame(columns=['a', 'b', 'c'])
         right = pd.DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]],
                              columns=['x', 'y', 'z'])
 
@@ -444,7 +444,7 @@ def test_merge_left_notempty_right_empty(self):
         # GH 10824
         left = pd.DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]],
                             columns=['a', 'b', 'c'])
-        right = pd.DataFrame([], columns=['x', 'y', 'z'])
+        right = pd.DataFrame(columns=['x', 'y', 'z'])
 
         exp_out = pd.DataFrame({'a': [1, 4, 7],
                                 'b': [2, 5, 8],

pandas/tests/reshape/test_concat.py

@@ -766,7 +766,7 @@ def test_append(self, sort):
             mixed_appended2.reindex(columns=['A', 'B', 'C', 'D']))
 
         # append empty
-        empty = DataFrame({})
+        empty = DataFrame()
 
         appended = self.frame.append(empty)
         tm.assert_frame_equal(self.frame, appended)
@@ -868,7 +868,7 @@ def test_append_many(self, sort):
 
     def test_append_preserve_index_name(self):
         # #980
-        df1 = DataFrame(data=None, columns=['A', 'B', 'C'])
+        df1 = DataFrame(columns=['A', 'B', 'C'])
         df1 = df1.set_index(['A'])
         df2 = DataFrame(data=[[1, 4, 7], [2, 5, 8], [3, 6, 9]],
                         columns=['A', 'B', 'C'])

pandas/tests/series/test_constructors.py

@@ -28,6 +28,30 @@
 
 class TestSeriesConstructors():
 
+    @pytest.mark.parametrize('constructor,check_index_type', [
+        # NOTE: some overlap with test_constructor_empty but that test does not
+        # test for None or an empty generator.
+        # test_constructor_pass_none tests None but only with the index also
+        # passed.
+        (lambda: Series(), True),
+        (lambda: Series(None), True),
+        (lambda: Series({}), True),
+        (lambda: Series(()), False),  # creates a RangeIndex
+        (lambda: Series([]), False),  # creates a RangeIndex
+        (lambda: Series((x for x in [])), False),  # creates a RangeIndex
+        (lambda: Series(data=None), True),
+        (lambda: Series(data={}), True),
+        (lambda: Series(data=()), False),  # creates a RangeIndex
+        (lambda: Series(data=[]), False),  # creates a RangeIndex
+        (lambda: Series(data=(x for x in [])), False),  # creates a RangeIndex
+    ])
+    def test_empty_constructor(self, constructor, check_index_type):
+        expected = Series()
+        result = constructor()
+        assert len(result.index) == 0
+        tm.assert_series_equal(result, expected,
+                               check_index_type=check_index_type)
+
     def test_invalid_dtype(self):
         # GH15520
         msg = 'not understood'
@@ -66,7 +90,7 @@ def test_constructor(self, datetime_series):
         assert mixed[1] is np.NaN
 
         assert not empty_series.index.is_all_dates
-        assert not Series({}).index.is_all_dates
+        assert not Series().index.is_all_dates
 
         # exception raised is of type Exception
         with pytest.raises(Exception, match="Data must be 1-dimensional"):

pandas/tests/test_multilevel.py

@@ -314,7 +314,7 @@ def test_count_level_corner(self):
 
         df = self.frame[:0]
         result = df.count(level=0)
-        expected = DataFrame({}, index=s.index.levels[0],
+        expected = DataFrame(index=s.index.levels[0],
                              columns=df.columns).fillna(0).astype(np.int64)
         tm.assert_frame_equal(result, expected)
 

pandas/tests/test_strings.py

@@ -1901,7 +1901,7 @@ def test_empty_str_methods(self):
 
     def test_empty_str_methods_to_frame(self):
         empty = Series(dtype=str)
-        empty_df = DataFrame([])
+        empty_df = DataFrame()
         tm.assert_frame_equal(empty_df, empty.str.partition('a'))
         tm.assert_frame_equal(empty_df, empty.str.rpartition('a'))
 
@@ -2551,7 +2551,7 @@ def test_split_blank_string(self):
         # expand blank split GH 20067
         values = Series([''], name='test')
         result = values.str.split(expand=True)
-        exp = DataFrame([[]])
+        exp = DataFrame([[]])  # NOTE: this is NOT an empty DataFrame
         tm.assert_frame_equal(result, exp)
 
         values = Series(['a b c', 'a b', '', ' '], name='test')