Wording and code organization fixes.

Author: sstanovnik

doc/source/whatsnew/v0.19.0.txt

@@ -437,7 +437,7 @@ API changes
 - ``pd.Timedelta(None)`` is now accepted and will return ``NaT``, mirroring ``pd.Timestamp`` (:issue:`13687`)
 - ``Timestamp``, ``Period``, ``DatetimeIndex``, ``PeriodIndex`` and ``.dt`` accessor have gained a ``.is_leap_year`` property to check whether the date belongs to a leap year. (:issue:`13727`)
 - ``pd.read_hdf`` will now raise a ``ValueError`` instead of ``KeyError``, if a mode other than ``r``, ``r+`` and ``a`` is supplied. (:issue:`13623`)
-- ``.values`` will now return ``np.float64`` with a ``DataFrame`` with ``np.int64`` and ``np.uint64`` dtypes, conforming to ``np.find_common_type`` (:issue:`10364`, :issue:`13917`)
+- ``DataFrame.values`` will now return ``float64`` with a ``DataFrame`` of mixed ``int64`` and ``uint64`` dtypes, conforming to ``np.find_common_type`` (:issue:`10364`, :issue:`13917`)
 
 
 
@@ -765,7 +765,7 @@ Note that the limitation is applied to ``fill_value`` which default is ``np.nan`
 - Bug in ``SparseDataFrame`` doesn't respect passed ``SparseArray`` or ``SparseSeries`` 's dtype and ``fill_value``  (:issue:`13866`)
 - Bug in ``SparseArray`` and ``SparseSeries`` don't apply ufunc to ``fill_value`` (:issue:`13853`)
 - Bug in ``SparseSeries.abs`` incorrectly keeps negative ``fill_value`` (:issue:`13853`)
-- Bug when interacting with multi-type SparseDataFrames: single row slicing now works because types are not forced to float (:issue:`13917`)
+- Bug in single row slicing on multi-type ``SparseDataFrame``s: types were previously forced to float (:issue:`13917`)
 
 .. _whatsnew_0190.deprecations:
 

pandas/sparse/tests/test_indexing.py

@@ -829,3 +829,81 @@ def test_reindex_fill_value(self):
         res = sparse.reindex(['A', 'C', 'B'])
         exp = orig.reindex(['A', 'C', 'B']).to_sparse(fill_value=0)
         tm.assert_sp_frame_equal(res, exp)
+
+
+class TestMultitype(tm.TestCase):
+    def setUp(self):
+        self.cols = ['string', 'int', 'float', 'object']
+
+        self.string_series = pd.SparseSeries(['a', 'b', 'c'])
+        self.int_series = pd.SparseSeries([1, 2, 3])
+        self.float_series = pd.SparseSeries([1.1, 1.2, 1.3])
+        self.object_series = pd.SparseSeries([[], {}, set()])
+        self.sdf = pd.SparseDataFrame({
+            'string': self.string_series,
+            'int': self.int_series,
+            'float': self.float_series,
+            'object': self.object_series,
+        })
+        self.sdf = self.sdf[self.cols]
+        self.ss = pd.SparseSeries(['a', 1, 1.1, []], index=self.cols)
+
+    def test_frame_basic_dtypes(self):
+        for _, row in self.sdf.iterrows():
+            self.assertEqual(row.dtype, object)
+        tm.assert_sp_series_equal(self.sdf['string'], self.string_series,
+                                  check_names=False)
+        tm.assert_sp_series_equal(self.sdf['int'], self.int_series,
+                                  check_names=False)
+        tm.assert_sp_series_equal(self.sdf['float'], self.float_series,
+                                  check_names=False)
+        tm.assert_sp_series_equal(self.sdf['object'], self.object_series,
+                                  check_names=False)
+
+    def test_frame_indexing_single(self):
+        tm.assert_sp_series_equal(self.sdf.iloc[0],
+                                  pd.SparseSeries(['a', 1, 1.1, []],
+                                                  index=self.cols),
+                                  check_names=False)
+        tm.assert_sp_series_equal(self.sdf.iloc[1],
+                                  pd.SparseSeries(['b', 2, 1.2, {}],
+                                                  index=self.cols),
+                                  check_names=False)
+        tm.assert_sp_series_equal(self.sdf.iloc[2],
+                                  pd.SparseSeries(['c', 3, 1.3, set()],
+                                                  index=self.cols),
+                                  check_names=False)
+
+    def test_frame_indexing_multiple(self):
+        tm.assert_sp_frame_equal(self.sdf, self.sdf[:])
+        tm.assert_sp_frame_equal(self.sdf, self.sdf.loc[:])
+        tm.assert_sp_frame_equal(self.sdf.iloc[[1, 2]],
+                                 pd.SparseDataFrame({
+                                     'string': self.string_series.iloc[[1, 2]],
+                                     'int': self.int_series.iloc[[1, 2]],
+                                     'float': self.float_series.iloc[[1, 2]],
+                                     'object': self.object_series.iloc[[1, 2]]
+                                 }, index=[1, 2])[self.cols])
+        tm.assert_sp_frame_equal(self.sdf[['int', 'string']],
+                                 pd.SparseDataFrame({
+                                     'int': self.int_series,
+                                     'string': self.string_series,
+                                 }))
+
+    def test_series_indexing_single(self):
+        for i, idx in enumerate(self.cols):
+            self.assertEqual(self.ss.iloc[i], self.ss[idx])
+            self.assertEqual(type(self.ss.iloc[i]),
+                             type(self.ss[idx]))
+        self.assertEqual(self.ss['string'], 'a')
+        self.assertEqual(self.ss['int'], 1)
+        self.assertEqual(self.ss['float'], 1.1)
+        self.assertEqual(self.ss['object'], [])
+
+    def test_series_indexing_multiple(self):
+        tm.assert_sp_series_equal(self.ss.loc[['string', 'int']],
+                                  pd.SparseSeries(['a', 1],
+                                                  index=['string', 'int']))
+        tm.assert_sp_series_equal(self.ss.loc[['string', 'object']],
+                                  pd.SparseSeries(['a', []],
+                                                  index=['string', 'object']))

pandas/sparse/tests/test_multitype.py

@@ -193,43 +193,37 @@ def test_possibly_convert_objects_copy(self):
 
 class TestCommonTypes(tm.TestCase):
     def test_numpy_dtypes(self):
-        # identity
-        self.assertEqual(_find_common_type([np.int64]), np.int64)
-        self.assertEqual(_find_common_type([np.uint64]), np.uint64)
-        self.assertEqual(_find_common_type([np.float32]), np.float32)
-        self.assertEqual(_find_common_type([np.object]), np.object)
-
-        # into ints
-        self.assertEqual(_find_common_type([np.int16, np.int64]),
-                         np.int64)
-        self.assertEqual(_find_common_type([np.int32, np.uint32]),
-                         np.int64)
-        self.assertEqual(_find_common_type([np.uint16, np.uint64]),
-                         np.uint64)
-
-        # into floats
-        self.assertEqual(_find_common_type([np.float16, np.float32]),
-                         np.float32)
-        self.assertEqual(_find_common_type([np.float16, np.int16]),
-                         np.float32)
-        self.assertEqual(_find_common_type([np.float32, np.int16]),
-                         np.float32)
-        self.assertEqual(_find_common_type([np.uint64, np.int64]),
-                         np.float64)
-        self.assertEqual(_find_common_type([np.int16, np.float64]),
-                         np.float64)
-        self.assertEqual(_find_common_type([np.float16, np.int64]),
-                         np.float64)
-
-        # into others
-        self.assertEqual(_find_common_type([np.complex128, np.int32]),
-                         np.complex128)
-        self.assertEqual(_find_common_type([np.object, np.float32]),
-                         np.object)
-        self.assertEqual(_find_common_type([np.object, np.int16]),
-                         np.object)
+        # (source_types, destination_type)
+        testcases = (
+            # identity
+            ((np.int64,), np.int64),
+            ((np.uint64,), np.uint64),
+            ((np.float32,), np.float32),
+            ((np.object,), np.object),
+
+            # into ints
+            ((np.int16, np.int64), np.int64),
+            ((np.int32, np.uint32), np.int64),
+            ((np.uint16, np.uint64), np.uint64),
+
+            # into floats
+            ((np.float16, np.float32), np.float32),
+            ((np.float16, np.int16), np.float32),
+            ((np.float32, np.int16), np.float32),
+            ((np.uint64, np.int64), np.float64),
+            ((np.int16, np.float64), np.float64),
+            ((np.float16, np.int64), np.float64),
+
+            # into others
+            ((np.complex128, np.int32), np.complex128),
+            ((np.object, np.float32), np.object),
+            ((np.object, np.int16), np.object),
+        )
+        for src, common in testcases:
+            self.assertEqual(_find_common_type(src), common)
 
     def test_pandas_dtypes(self):
+        # TODO: not implemented yet
         with self.assertRaises(TypeError):
             self.assertEqual(_find_common_type([CategoricalDtype()]),
                              CategoricalDtype)