added FutureWarning to empty Series without dtype and adjusted the tests so that no unnecessary warnings are thrown

Author: SaturnFromTitan

doc/source/user_guide/missing_data.rst

@@ -186,6 +186,7 @@ Sum/prod of empties/nans
 The sum of an empty or all-NA Series or column of a DataFrame is 0.
 
 .. ipython:: python
+   :okwarning:
 
    pd.Series([np.nan]).sum()
 
@@ -194,6 +195,7 @@ The sum of an empty or all-NA Series or column of a DataFrame is 0.
 The product of an empty or all-NA Series or column of a DataFrame is 1.
 
 .. ipython:: python
+   :okwarning:
 
    pd.Series([np.nan]).prod()
 

doc/source/whatsnew/v1.0.0.rst

@@ -201,6 +201,9 @@ Other API changes
   See :ref:`units registration <whatsnew_1000.matplotlib_units>` for more.
 - :meth:`Series.dropna` has dropped its ``**kwargs`` argument in favor of a single ``how`` parameter.
   Supplying anything else than ``how`` to ``**kwargs`` raised a ``TypeError`` previously (:issue:`29388`)
+- Initialising an empty :class:`pandas.core.series.Series` without specifying a dtype will raise a FutureWarning now.
+  The default dtype will change from ``float64`` to ``object`` in future releases so that it is consistent with the
+  behaviour of :class:`pandas.core.frame.DataFrame` and :class:`pandas.core.indexes.base.Index`.
 -
 
 
@@ -243,7 +246,7 @@ Removal of prior version deprecations/changes
 
 Previously, pandas would register converters with matplotlib as a side effect of importing pandas (:issue:`18720`).
 This changed the output of plots made via matplotlib plots after pandas was imported, even if you were using
-matplotlib directly rather than rather than :meth:`~DataFrame.plot`.
+matplotlib directly rather than :meth:`~DataFrame.plot`.
 
 To use pandas formatters with a matplotlib plot, specify
 

pandas/compat/pickle_compat.py

@@ -64,7 +64,7 @@ def __new__(cls) -> "Series":  # type: ignore
             stacklevel=6,
         )
 
-        return Series()
+        return Series(dtype=object)
 
 
 class _LoadSparseFrame:

pandas/core/apply.py

@@ -1,6 +1,6 @@
 import abc
 import inspect
-from typing import TYPE_CHECKING, Any, Dict, Iterator, Tuple, Type, Union
+from typing import TYPE_CHECKING, Any, Dict, Iterator, Optional, Type, Union
 
 import numpy as np
 
@@ -202,15 +202,15 @@ def apply_empty_result(self):
 
         if not should_reduce:
             try:
-                r = self.f(Series([]))
+                r = self.f(Series([], dtype=np.float64))
             except Exception:
                 pass
             else:
                 should_reduce = not isinstance(r, Series)
 
         if should_reduce:
             if len(self.agg_axis):
-                r = self.f(Series([]))
+                r = self.f(Series([], dtype=np.float64))
             else:
                 r = np.nan
 
@@ -343,14 +343,21 @@ def apply_series_generator(self) -> Tuple[ResType, "Index"]:
     def wrap_results(
         self, results: ResType, res_index: "Index"
     ) -> Union["Series", "DataFrame"]:
+        from pandas import Series
 
         # see if we can infer the results
         if len(results) > 0 and 0 in results and is_sequence(results[0]):
 
             return self.wrap_results_for_axis(results, res_index)
 
         # dict of scalars
-        result = self.obj._constructor_sliced(results)
+        # TODO: Remove if/else block when default dtype of Series is changed to object
+        constructor_sliced = self.obj._constructor_sliced
+        is_empty = isinstance(results, (list, tuple, dict)) and not results
+        if constructor_sliced is Series and is_empty:
+            result = constructor_sliced(results, dtype=np.float64)
+        else:
+            result = constructor_sliced(results)
         result.index = res_index
 
         return result

pandas/core/base.py

@@ -1256,7 +1256,10 @@ def _map_values(self, mapper, na_action=None):
                 # possibility that they are tuples
                 from pandas import Series
 
-                mapper = Series(mapper)
+                if not mapper:
+                    mapper = Series(mapper, dtype=np.float64)
+                else:
+                    mapper = Series(mapper)
 
         if isinstance(mapper, ABCSeries):
             # Since values were input this means we came from either

pandas/core/frame.py

@@ -8116,7 +8116,8 @@ def quantile(self, q=0.5, axis=0, numeric_only=True, interpolation="linear"):
             cols = Index([], name=self.columns.name)
             if is_list_like(q):
                 return self._constructor([], index=q, columns=cols)
-            return self._constructor_sliced([], index=cols, name=q)
+
+            return self._constructor_sliced([], index=cols, name=q, dtype=np.float64)
 
         result = data._data.quantile(
             qs=q, axis=1, interpolation=interpolation, transposed=is_transposed

pandas/core/generic.py

@@ -6281,6 +6281,8 @@ def fillna(
         2   NaN 1.0 NaN 5
         3   NaN 3.0 NaN 4
         """
+        from pandas import Series
+
         inplace = validate_bool_kwarg(inplace, "inplace")
         value, method = validate_fillna_kwargs(value, method)
 
@@ -6317,8 +6319,10 @@ def fillna(
                 return self
 
             if self.ndim == 1:
-                if isinstance(value, (dict, ABCSeries)):
-                    from pandas import Series
+                if isinstance(value, dict):
+                    dtype = object if not value else None
+                    value = Series(value, dtype=dtype)
+                elif isinstance(value, ABCSeries):
 
                     value = Series(value)
                 elif not is_list_like(value):
@@ -7263,7 +7267,7 @@ def asof(self, where, subset=None):
                 if not is_series:
                     from pandas import Series
 
-                    return Series(index=self.columns, name=where)
+                    return Series(index=self.columns, name=where, dtype=np.float64)
                 return np.nan
 
             # It's always much faster to use a *while* loop here for

pandas/core/groupby/generic.py

@@ -251,7 +251,13 @@ def aggregate(self, func=None, *args, **kwargs):
                 result = self._aggregate_named(func, *args, **kwargs)
 
             index = Index(sorted(result), name=self.grouper.names[0])
-            ret = Series(result, index=index)
+
+            # TODO: if/else can be removed as soon as default dtype
+            #  for empty series is changed object
+            if result:
+                ret = Series(result, index=index)
+            else:
+                ret = Series(result, index=index, dtype=object)
 
         if not self.as_index:  # pragma: no cover
             print("Warning, ignoring as_index=True")
@@ -348,7 +354,7 @@ def _wrap_transformed_output(self, output, names=None):
     def _wrap_applied_output(self, keys, values, not_indexed_same=False):
         if len(keys) == 0:
             # GH #6265
-            return Series([], name=self._selection_name, index=keys)
+            return Series([], name=self._selection_name, index=keys, dtype=np.float64)
 
         def _get_index() -> Index:
             if self.grouper.nkeys > 1:
@@ -430,7 +436,7 @@ def transform(self, func, *args, **kwargs):
 
             result = concat(results).sort_index()
         else:
-            result = Series()
+            result = Series(dtype=np.float64)
 
         # we will only try to coerce the result type if
         # we have a numeric dtype, as these are *always* udfs
@@ -1164,9 +1170,17 @@ def first_not_none(values):
             if v is None:
                 return DataFrame()
             elif isinstance(v, NDFrame):
+
+                # this is to silence a FutureWarning
+                # TODO: Remove when default dtype of empty Series is object
+                kwargs = v._construct_axes_dict()
+                if v._constructor is Series:
+                    is_empty = "data" not in kwargs or not kwargs["data"]
+                    if "dtype" not in kwargs and is_empty:
+                        kwargs["dtype"] = object
+
                 values = [
-                    x if x is not None else v._constructor(**v._construct_axes_dict())
-                    for x in values
+                    x if (x is not None) else v._constructor(**kwargs) for x in values
                 ]
 
             v = values[0]

pandas/core/series.py

@@ -202,6 +202,19 @@ class Series(base.IndexOpsMixin, generic.NDFrame):
     def __init__(
         self, data=None, index=None, dtype=None, name=None, copy=False, fastpath=False
     ):
+        no_data = data is None or (isinstance(data, (list, tuple, dict)) and not data)
+        if no_data and dtype is None:
+            # Empty Series should have dtype object to be consistent
+            # with the behaviour of DataFrame and Index
+            warnings.warn(
+                "The default dtype for empty Series will be 'object' instead"
+                " of 'float64' in the next version. Specify a dtype explicitly"
+                " to silence this warning.",
+                FutureWarning,
+                stacklevel=2,
+            )
+            # uncomment the line below when removing the FutureWarning
+            # dtype = np.dtype(object)
 
         # we are called internally, so short-circuit
         if fastpath:
@@ -357,7 +370,11 @@ def _init_dict(self, data, index=None, dtype=None):
             keys, values = [], []
 
         # Input is now list-like, so rely on "standard" construction:
-        s = Series(values, index=keys, dtype=dtype)
+        # TODO: warning filter can be removed when default dtype for Series
+        #  is changed to object.
+        with warnings.catch_warnings():
+            warnings.simplefilter(action="ignore", category=FutureWarning)
+            s = Series(values, index=keys, dtype=dtype)
 
         # Now we just make sure the order is respected, if any
         if data and index is not None:

pandas/core/tools/datetimes.py

@@ -145,7 +145,8 @@ def _maybe_cache(arg, format, cache, convert_listlike):
     """
     from pandas import Series
 
-    cache_array = Series()
+    cache_array = Series(dtype=object)
+
     if cache:
         # Perform a quicker unique check
         if not should_cache(arg):