Better error for str.cat with listlike of wrong dtype.

doc/source/whatsnew/v0.25.0.rst

@@ -607,7 +607,7 @@ Strings
 ^^^^^^^
 
 - Bug in the ``__name__`` attribute of several methods of :class:`Series.str`, which were set incorrectly (:issue:`23551`)
--
+- Improved error message when passing ``Series`` of wrong dtype to :meth:`Series.str.cat` (:issue:`22722`)
 -
 
 

pandas/core/strings.py

@@ -53,6 +53,27 @@ def cat_core(list_of_columns, sep):
     return np.sum(list_with_sep, axis=0)
 
 
+def cat_safe(list_of_columns, sep):
+    """
+    Auxiliary function for :meth:`str.cat`.
+
+    Same signature as cat_core, but handles TypeErrors in concatenation, which
+    happen if the Series in list_of columns have the wrong dtypes or content.
+    """
+    # if there are any non-string values (wrong dtype or hidden behind object
+    # dtype), np.sum will fail; catch error and return with better message
+    try:
+        result = cat_core(list_of_columns, sep)
+    except TypeError:
+        dtypes = [lib.infer_dtype(x, skipna=True) for x in list_of_columns]
+        illegal = [x not in ('string', 'empty') for x in dtypes]
+        first_offender = [x for x, y in zip(list_of_columns, illegal) if y][0]
+        raise TypeError('Concatenation requires list-likes containing only '
+                        'strings (or missing values). Offending values found '
+                        'in column {}'.format(first_offender)) from None
+    return result
+
+
 def _na_map(f, arr, na_result=np.nan, dtype=object):
     # should really _check_ for NA
     return _map(f, arr, na_mask=True, na_value=na_result, dtype=dtype)
@@ -2314,16 +2335,16 @@ def cat(self, others=None, sep=None, na_rep=None, join=None):
             np.putmask(result, union_mask, np.nan)
 
             not_masked = ~union_mask
-            result[not_masked] = cat_core([x[not_masked] for x in all_cols],
+            result[not_masked] = cat_safe([x[not_masked] for x in all_cols],
                                           sep)
         elif na_rep is not None and union_mask.any():
             # fill NaNs with na_rep in case there are actually any NaNs
             all_cols = [np.where(nm, na_rep, col)
                         for nm, col in zip(na_masks, all_cols)]
-            result = cat_core(all_cols, sep)
+            result = cat_safe(all_cols, sep)
         else:
             # no NaNs - can just concatenate
-            result = cat_core(all_cols, sep)
+            result = cat_safe(all_cols, sep)
 
         if isinstance(self._orig, Index):
             # add dtype for case that result is all-NA

pandas/tests/test_strings.py

@@ -428,6 +428,23 @@ def test_str_cat_categorical(self, box, dtype_caller, dtype_target, sep):
             result = s.str.cat(t, sep=sep)
             assert_series_or_index_equal(result, expected)
 
+    # test integer/float dtypes (inferred by constructor) and mixed
+    @pytest.mark.parametrize('data', [[1, 2, 3], [.1, .2, .3], [1, 2, 'b']],
+                             ids=['integers', 'floats', 'mixed'])
+    # without dtype=object, np.array would cast [1, 2, 'b'] to ['1', '2', 'b']
+    @pytest.mark.parametrize('box', [Series, Index, list,
+                                     lambda x: np.array(x, dtype=object)],
+                             ids=['Series', 'Index', 'list', 'np.array'])
+    def test_str_cat_wrong_dtype_raises(self, box, data):
+        # GH 22722
+        s = Series(['a', 'b', 'c'])
+        t = box(data)
+
+        msg = 'Concatenation requires list-likes containing only strings.*'
+        with pytest.raises(TypeError, match=msg):
+            # need to use outer and na_rep, as otherwise Index would not raise
+            s.str.cat(t, join='outer', na_rep='-')
+
     @pytest.mark.parametrize('box', [Series, Index])
     def test_str_cat_mixed_inputs(self, box):
         s = Index(['a', 'b', 'c', 'd'])