use elifs and parametrize tests

Author: reidy-p

doc/source/whatsnew/v0.22.0.txt

@@ -186,7 +186,6 @@ Other API Changes
 - :func:`Series.fillna` now raises a ``TypeError`` instead of a ``ValueError`` when passed a list, tuple or DataFrame as a ``value`` (:issue:`18293`)
 - :func:`pandas.DataFrame.merge` no longer casts a ``float`` column to ``object`` when merging on ``int`` and ``float`` columns (:issue:`16572`)
 - The default NA value for :class:`UInt64Index` has changed from 0 to ``NaN``, which impacts methods that mask with NA, such as ``UInt64Index.where()`` (:issue:`18398`)
-- Building pandas for development now requires ``cython >= 0.24`` (:issue:`18613`)
 - :func:`pandas.merge` now raises a ``ValueError`` when trying to merge on incompatible data types (:issue:`9780`)
 
 .. _whatsnew_0220.deprecations:

pandas/core/reshape/merge.py

@@ -963,30 +963,41 @@ def _maybe_coerce_merge_keys(self):
                 elif lib.infer_dtype(lk) == lib.infer_dtype(rk):
                     pass
 
-            else:
-
-                # Check if we are trying to merge on obviously
-                # incompatible dtypes GH 9780
+            # Check if we are trying to merge on obviously
+            # incompatible dtypes GH 9780
+            elif is_numeric_dtype(lk) and not is_numeric_dtype(rk):
+                msg = ("You are trying to merge on {lk_dtype} and "
+                       "{rk_dtype} columns. If you wish to proceed "
+                       "you should use pd.concat".format(lk_dtype=lk.dtype,
+                                                         rk_dtype=rk.dtype))
+                raise ValueError(msg)
+            elif not is_numeric_dtype(lk) and is_numeric_dtype(rk):
                 msg = ("You are trying to merge on {lk_dtype} and "
                        "{rk_dtype} columns. If you wish to proceed "
                        "you should use pd.concat".format(lk_dtype=lk.dtype,
                                                          rk_dtype=rk.dtype))
-                if is_numeric_dtype(lk) and not is_numeric_dtype(rk):
-                    raise ValueError(msg)
-                elif not is_numeric_dtype(lk) and is_numeric_dtype(rk):
-                    raise ValueError(msg)
-                elif is_datetimelike(lk) and not is_datetimelike(rk):
-                    raise ValueError(msg)
-                elif not is_datetimelike(lk) and is_datetimelike(rk):
-                    raise ValueError(msg)
-
-                # Houston, we have a problem!
-                # let's coerce to object if the dtypes aren't
-                # categorical, otherwise coerce to the category
-                # dtype. If we coerced categories to object,
-                # then we would lose type information on some
-                # columns, and end up trying to merge
-                # incompatible dtypes. See GH 16900.
+                raise ValueError(msg)
+            elif is_datetimelike(lk) and not is_datetimelike(rk):
+                msg = ("You are trying to merge on {lk_dtype} and "
+                       "{rk_dtype} columns. If you wish to proceed "
+                       "you should use pd.concat".format(lk_dtype=lk.dtype,
+                                                         rk_dtype=rk.dtype))
+                raise ValueError(msg)
+            elif not is_datetimelike(lk) and is_datetimelike(rk):
+                msg = ("You are trying to merge on {lk_dtype} and "
+                       "{rk_dtype} columns. If you wish to proceed "
+                       "you should use pd.concat".format(lk_dtype=lk.dtype,
+                                                         rk_dtype=rk.dtype))
+                raise ValueError(msg)
+
+            # Houston, we have a problem!
+            # let's coerce to object if the dtypes aren't
+            # categorical, otherwise coerce to the category
+            # dtype. If we coerced categories to object,
+            # then we would lose type information on some
+            # columns, and end up trying to merge
+            # incompatible dtypes. See GH 16900.
+            else:
                 if name in self.left.columns:
                     typ = lk.categories.dtype if lk_is_cat else object
                     self.left = self.left.assign(

pandas/tests/reshape/merge/test_merge.py

@@ -1371,42 +1371,46 @@ def f():
         pytest.raises(NotImplementedError, f)
 
 
-@pytest.fixture
-def df():
-    return DataFrame(
-        {'A': ['foo', 'bar'],
-         'B': Series(['foo', 'bar']).astype('category'),
-         'C': [1, 2],
-         'D': [1.0, 2.0],
-         'E': Series([1, 2], dtype='uint64'),
-         'F': Series([1, 2], dtype='int32')})
+class TestMergeDtypes(object):
 
+    @pytest.mark.parametrize('right_vals', [
+        ['foo', 'bar'],
+        Series(['foo', 'bar']).astype('category'),
+        [1, 2],
+        [1.0, 2.0],
+        Series([1, 2], dtype='uint64'),
+        Series([1, 2], dtype='int32')
+    ]
+    )
+    def test_different(self, right_vals):
+
+        left = DataFrame({'A': ['foo', 'bar'],
+                          'B': Series(['foo', 'bar']).astype('category'),
+                          'C': [1, 2],
+                          'D': [1.0, 2.0],
+                          'E': Series([1, 2], dtype='uint64'),
+                          'F': Series([1, 2], dtype='int32')})
+        right = DataFrame({'A': right_vals})
 
-class TestMergeDtypes(object):
+        # GH 9780
+        # We allow merging on object and categorical cols and cast
+        # categorical cols to object
+        if (is_categorical_dtype(right['A'].dtype) or
+           is_object_dtype(right['A'].dtype)):
+            result = pd.merge(left, right, on='A')
+            assert is_object_dtype(result.A.dtype)
 
-    def test_different(self, df):
-
-        left = df
-        for col in df.columns:
-            right = DataFrame({'A': df[col]})
-            # GH 9780
-            # We allow merging on object and categorical cols and cast
-            # categorical cols to object
-            if (is_categorical_dtype(right['A'].dtype) or
-               is_object_dtype(right['A'].dtype)):
-                result = pd.merge(left, right, on='A')
-                assert is_object_dtype(result.A.dtype)
-            # GH 9780
-            # We raise for merging on object col and int/float col and
-            # merging on categorical col and int/float col
-            else:
-                msg = ("You are trying to merge on "
-                       "{lk_dtype} and {rk_dtype} columns. "
-                       "If you wish to proceed you should use "
-                       "pd.concat".format(lk_dtype=left['A'].dtype,
-                                          rk_dtype=right['A'].dtype))
-                with tm.assert_raises_regex(ValueError, msg):
-                    pd.merge(left, right, on='A')
+        # GH 9780
+        # We raise for merging on object col and int/float col and
+        # merging on categorical col and int/float col
+        else:
+            msg = ("You are trying to merge on "
+                   "{lk_dtype} and {rk_dtype} columns. "
+                   "If you wish to proceed you should use "
+                   "pd.concat".format(lk_dtype=left['A'].dtype,
+                                      rk_dtype=right['A'].dtype))
+            with tm.assert_raises_regex(ValueError, msg):
+                pd.merge(left, right, on='A')
 
     @pytest.mark.parametrize('d1', [np.int64, np.int32,
                                     np.int16, np.int8, np.uint8])