DEPR: Deprecate Series/Dataframe.to_dense/to_sparse

pandas/core/frame.py

@@ -1889,6 +1889,8 @@ def to_sparse(self, fill_value=None, kind='block'):
         """
         Convert to SparseDataFrame.
 
+        .. deprecated:: 0.25.0
+
         Implement the sparse version of the DataFrame meaning that any data
         matching a specific value it's omitted in the representation.
         The sparse DataFrame allows for a more efficient storage.
@@ -1939,6 +1941,9 @@ def to_sparse(self, fill_value=None, kind='block'):
         >>> type(sdf)  # doctest: +SKIP
         <class 'pandas.core.sparse.frame.SparseDataFrame'>
         """
+        warnings.warn("DataFrame.to_sparse is deprecated and will be removed "
+                      "in a future version", FutureWarning, stacklevel=2)
+
         from pandas.core.sparse.api import SparseDataFrame
         return SparseDataFrame(self._series, index=self.index,
                                columns=self.columns, default_kind=kind,
@@ -2282,7 +2287,7 @@ def info(self, verbose=None, buf=None, max_cols=None, memory_usage=None,
         text_col     5 non-null object
         float_col    5 non-null float64
         dtypes: float64(1), int64(1), object(1)
-        memory usage: 200.0+ bytes
+        memory usage: 248.0+ bytes
 
         Prints a summary of columns count and its dtypes but not per column
         information:
@@ -2292,7 +2297,7 @@ def info(self, verbose=None, buf=None, max_cols=None, memory_usage=None,
         RangeIndex: 5 entries, 0 to 4
         Columns: 3 entries, int_col to float_col
         dtypes: float64(1), int64(1), object(1)
-        memory usage: 200.0+ bytes
+        memory usage: 248.0+ bytes
 
         Pipe output of DataFrame.info to buffer instead of sys.stdout, get
         buffer content and writes to a text file:
@@ -2494,7 +2499,7 @@ def memory_usage(self, index=True, deep=False):
         4      1      1.0    1.0+0.0j       1  True
 
         >>> df.memory_usage()
-        Index            80
+        Index           128
         int64         40000
         float64       40000
         complex128    80000
@@ -2513,7 +2518,7 @@ def memory_usage(self, index=True, deep=False):
         The memory footprint of `object` dtype columns is ignored by default:
 
         >>> df.memory_usage(deep=True)
-        Index             80
+        Index            128
         int64          40000
         float64        40000
         complex128     80000
@@ -2525,7 +2530,7 @@ def memory_usage(self, index=True, deep=False):
         many repeated values.
 
         >>> df['object'].astype('category').memory_usage(deep=True)
-        5168
+        5216
         """
         result = Series([c.memory_usage(index=False, deep=deep)
                          for col, c in self.iteritems()], index=self.columns)

pandas/core/generic.py

@@ -1964,11 +1964,16 @@ def to_dense(self):
         """
         Return dense representation of NDFrame (as opposed to sparse).
 
+        .. deprecated:: 0.25.0
+
         Returns
         -------
         %(klass)s
             Dense %(klass)s.
         """
+        warnings.warn("NDFrame.to_dense is deprecated "
+                      "and will be removed in a future version",
+                      FutureWarning, stacklevel=2)
         # compat
         return self
 

pandas/core/groupby/ops.py

@@ -630,9 +630,9 @@ def _aggregate_series_fast(self, obj, func):
         group_index, _, ngroups = self.group_info
 
         # avoids object / Series creation overhead
-        dummy = obj._get_values(slice(None, 0)).to_dense()
+        dummy = obj._get_values(slice(None, 0))
         indexer = get_group_index_sorter(group_index, ngroups)
-        obj = obj._take(indexer).to_dense()
+        obj = obj._take(indexer)
         group_index = algorithms.take_nd(
             group_index, indexer, allow_fill=False)
         grouper = reduction.SeriesGrouper(obj, func, group_index, ngroups,
@@ -879,7 +879,7 @@ def apply(self, f):
 class SeriesSplitter(DataSplitter):
 
     def _chop(self, sdata, slice_obj):
-        return sdata._get_values(slice_obj).to_dense()
+        return sdata._get_values(slice_obj)
 
 
 class FrameSplitter(DataSplitter):

pandas/core/series.py

@@ -1575,6 +1575,8 @@ def to_sparse(self, kind='block', fill_value=None):
         """
         Convert Series to SparseSeries.
 
+        .. deprecated:: 0.25.0
+
         Parameters
         ----------
         kind : {'block', 'integer'}, default 'block'
@@ -1586,6 +1588,9 @@ def to_sparse(self, kind='block', fill_value=None):
         SparseSeries
             Sparse representation of the Series.
         """
+
+        warnings.warn("Series.to_sparse is deprecated and will be removed "
+                      "in a future version", FutureWarning, stacklevel=2)
         from pandas.core.sparse.series import SparseSeries
 
         values = SparseArray(self, kind=kind, fill_value=fill_value)
@@ -4010,7 +4015,7 @@ def memory_usage(self, index=True, deep=False):
         --------
         >>> s = pd.Series(range(3))
         >>> s.memory_usage()
-        104
+        152
 
         Not including the index gives the size of the rest of the data, which
         is necessarily smaller:
@@ -4024,9 +4029,9 @@ def memory_usage(self, index=True, deep=False):
         >>> s.values
         array(['a', 'b'], dtype=object)
         >>> s.memory_usage()
-        96
+        144
         >>> s.memory_usage(deep=True)
-        212
+        260
         """
         v = super().memory_usage(deep=deep)
         if index:

pandas/core/sparse/frame.py

@@ -242,6 +242,11 @@ def _init_spmatrix(self, data, index, columns, dtype=None,
     def to_coo(self):
         return SparseFrameAccessor(self).to_coo()
 
+    def __repr__(self):
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", "Sparse")
+            return super().__repr__()
+
     def __getstate__(self):
         # pickling
         return dict(_typ=self._typ, _subtyp=self._subtyp, _data=self._data,
@@ -277,6 +282,21 @@ def _unpickle_sparse_frame_compat(self, state):
 
     @Appender(SparseFrameAccessor.to_dense.__doc__)
     def to_dense(self):
+        """
+        .. deprecated:: 0.25.0
+            Use Dataframe.sparse.to_dense() instead
+        """
+
+        warning_message = """\
+SparseDataFrame.to_dense is deprecated and will be removed in a future version
+
+            Use Dataframe.sparse.to_dense() instead
+
+            >>> df = pd.DataFrame({"A": pd.SparseArray([0, 1, 0])})
+            >>> df.sparse.to_dense()
+            """
+        warnings.warn(warning_message, FutureWarning, stacklevel=2)
+
         return SparseFrameAccessor(self).to_dense()
 
     def _apply_columns(self, func):

pandas/core/sparse/series.py

@@ -214,10 +214,12 @@ def as_sparse_array(self, kind=None, fill_value=None, copy=False):
                            fill_value=fill_value, kind=kind, copy=copy)
 
     def __repr__(self):
-        series_rep = Series.__repr__(self)
-        rep = '{series}\n{index!r}'.format(series=series_rep,
-                                           index=self.sp_index)
-        return rep
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", "Sparse")
+            series_rep = Series.__repr__(self)
+            rep = '{series}\n{index!r}'.format(series=series_rep,
+                                               index=self.sp_index)
+            return rep
 
     def _reduce(self, op, name, axis=0, skipna=True, numeric_only=None,
                 filter_type=None, **kwds):
@@ -429,11 +431,15 @@ def _set_values(self, key, value):
     def to_dense(self):
         """
         Convert SparseSeries to a Series.
-
+        .. deprecated:: 0.25.0
         Returns
         -------
         s : Series
         """
+        warnings.warn("SparseSeries.to_dense is deprecated "
+                      "and will be removed in a future version",
+                      FutureWarning, stacklevel=2)
+
         return Series(self.values.to_dense(), index=self.index,
                       name=self.name)
 

pandas/tests/arrays/sparse/test_arithmetics.py

@@ -9,6 +9,7 @@
 
 
 @pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
+@pytest.mark.filterwarnings("ignore:Series.to_sparse:FutureWarning")
 class TestSparseArrayArithmetics:
 
     _base = np.array

pandas/tests/frame/test_deprecations.py

@@ -0,0 +1,17 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas.util import testing as tm
+
+
+@pytest.mark.filterwarnings("ignore:Sparse:FutureWarning")
+def test_deprecated_to_sparse():
+    df = pd.DataFrame({"A": [1, np.nan, 3]})
+    sparse_df = pd.SparseDataFrame({"A": [1, np.nan, 3]})
+
+    # Deprecated 0.25.0
+    with tm.assert_produces_warning(FutureWarning,
+                                    check_stacklevel=False):
+        result = df.to_sparse()
+    tm.assert_frame_equal(result, sparse_df)

pandas/tests/generic/test_generic.py

@@ -918,3 +918,16 @@ def test_axis_classmethods(self, box):
             assert obj._get_axis_name(v) == box._get_axis_name(v)
             assert obj._get_block_manager_axis(v) == \
                 box._get_block_manager_axis(v)
+
+    def test_deprecated_to_dense(self):
+        # Deprecated 0.25.0
+
+        df = pd.DataFrame({"A": [1, 2, 3]})
+        with tm.assert_produces_warning(FutureWarning):
+            result = df.to_dense()
+        tm.assert_frame_equal(result, df)
+
+        ser = pd.Series([1, 2, 3])
+        with tm.assert_produces_warning(FutureWarning):
+            result = ser.to_dense()
+        tm.assert_series_equal(result, ser)

pandas/tests/io/json/test_pandas.py

@@ -1018,13 +1018,19 @@ def test_sparse(self):
         df = pd.DataFrame(np.random.randn(10, 4))
         df.loc[:8] = np.nan
 
-        sdf = df.to_sparse()
+        # GH 26557: DEPR
+        with tm.assert_produces_warning(FutureWarning,
+                                        check_stacklevel=False):
+            sdf = df.to_sparse()
         expected = df.to_json()
         assert expected == sdf.to_json()
 
         s = pd.Series(np.random.randn(10))
         s.loc[:8] = np.nan
-        ss = s.to_sparse()
+        # GH 26557: DEPR
+        with tm.assert_produces_warning(FutureWarning,
+                                        check_stacklevel=False):
+            ss = s.to_sparse()
 
         expected = s.to_json()
         assert expected == ss.to_json()

pandas/tests/io/test_packers.py

@@ -566,15 +566,24 @@ def test_sparse_series(self):
 
         s = tm.makeStringSeries()
         s[3:5] = np.nan
-        ss = s.to_sparse()
+        # GH 26557: DEPR
+        with tm.assert_produces_warning(FutureWarning,
+                                        check_stacklevel=False):
+            ss = s.to_sparse()
         self._check_roundtrip(ss, tm.assert_series_equal,
                               check_series_type=True)
 
-        ss2 = s.to_sparse(kind='integer')
+        # GH 26557: DEPR
+        with tm.assert_produces_warning(FutureWarning,
+                                        check_stacklevel=False):
+            ss2 = s.to_sparse(kind='integer')
         self._check_roundtrip(ss2, tm.assert_series_equal,
                               check_series_type=True)
 
-        ss3 = s.to_sparse(fill_value=0)
+        # GH 26557: DEPR
+        with tm.assert_produces_warning(FutureWarning,
+                                        check_stacklevel=False):
+            ss3 = s.to_sparse(fill_value=0)
         self._check_roundtrip(ss3, tm.assert_series_equal,
                               check_series_type=True)
 
@@ -583,16 +592,25 @@ def test_sparse_frame(self):
         s = tm.makeDataFrame()
         s.loc[3:5, 1:3] = np.nan
         s.loc[8:10, -2] = np.nan
-        ss = s.to_sparse()
+        # GH 26557: DEPR
+        with tm.assert_produces_warning(FutureWarning,
+                                        check_stacklevel=False):
+            ss = s.to_sparse()
 
         self._check_roundtrip(ss, tm.assert_frame_equal,
                               check_frame_type=True)
 
-        ss2 = s.to_sparse(kind='integer')
+        # GH 26557: DEPR
+        with tm.assert_produces_warning(FutureWarning,
+                                        check_stacklevel=False):
+            ss2 = s.to_sparse(kind='integer')
         self._check_roundtrip(ss2, tm.assert_frame_equal,
                               check_frame_type=True)
 
-        ss3 = s.to_sparse(fill_value=0)
+        # GH 26557: DEPR
+        with tm.assert_produces_warning(FutureWarning,
+                                        check_stacklevel=False):
+            ss3 = s.to_sparse(fill_value=0)
         self._check_roundtrip(ss3, tm.assert_frame_equal,
                               check_frame_type=True)