Fix fill value, closes pandas-dev#26987

Author: jbrockmendel

pandas/core/missing.py

@@ -702,7 +702,7 @@ def dispatch_missing(op, left, right, result):
     result : ndarray
     """
     opstr = "__{opname}__".format(opname=op.__name__).replace("____", "__")
-    if op in [operator.truediv, operator.floordiv, getattr(operator, "div", None)]:
+    if op in [operator.truediv, operator.floordiv]:
         result = mask_zero_div_zero(left, right, result)
     elif op is operator.mod:
         result = fill_zeros(result, left, right, opstr, np.nan)
@@ -713,6 +713,29 @@ def dispatch_missing(op, left, right, result):
     return result
 
 
+# FIXME: de-duplicate with dispatch_missing
+def dispatch_fill_zeros(op, left, right, result, fill_value):
+    """
+    Call fill_zeros with the appropriate fill value depending on the operation,
+    with special logic for divmod and rdivmod.
+    """
+    from pandas.core.ops import rdivmod
+
+    if op is divmod:
+        result = (
+            fill_zeros(result[0], left, right, "__floordiv__", np.inf),
+            fill_zeros(result[1], left, right, "__mod__", np.nan),
+        )
+    elif op is rdivmod:
+        result = (
+            fill_zeros(result[0], left, right, "__rfloordiv__", np.inf),
+            fill_zeros(result[1], left, right, "__rmod__", np.nan),
+        )
+    else:
+        result = fill_zeros(result, left, right, op.__name__, fill_value)
+    return result
+
+
 def _interp_limit(invalid, fw_limit, bw_limit):
     """
     Get indexers of values that won't be filled

pandas/core/ops.py

@@ -295,7 +295,7 @@ def _gen_fill_zeros(name):
     """
     name = name.strip("__")
     if "div" in name:
-        # truediv, floordiv, div, and reversed variants
+        # truediv, floordiv, and reversed variants
         fill_value = np.inf
     elif "mod" in name:
         # mod, rmod
@@ -1718,14 +1718,7 @@ def na_op(x, y):
                 return libalgos.arrmap_object(x, lambda val: op(val, y))
             raise
 
-        if isinstance(result, tuple):
-            # e.g. divmod
-            result = tuple(
-                missing.fill_zeros(r, x, y, op_name, fill_zeros) for r in result
-            )
-        else:
-            result = missing.fill_zeros(result, x, y, op_name, fill_zeros)
-        return result
+        return missing.dispatch_fill_zeros(op, x, y, result, fill_zeros)
 
     def wrapper(left, right):
         if isinstance(right, ABCDataFrame):

pandas/tests/arithmetic/test_numeric.py

@@ -299,6 +299,54 @@ def test_ser_div_ser(self, dtype1, dtype2):
         tm.assert_series_equal(result, expected)
         assert not result.equals(second / first)
 
+    @pytest.mark.parametrize(
+        "dtype2",
+        [
+            np.int64,
+            np.int32,
+            np.int16,
+            np.int8,
+            np.float64,
+            np.float32,
+            np.float16,
+            np.uint64,
+            np.uint32,
+            np.uint16,
+            np.uint8,
+        ],
+    )
+    @pytest.mark.parametrize("dtype1", [np.int64, np.float64, np.uint64])
+    def test_ser_divmod_zero(self, dtype1, dtype2):
+        # GH#26987
+        left = pd.Series([1, 1]).astype(dtype1)
+        right = pd.Series([0, 2]).astype(dtype2)
+
+        expected = left // right, left % right
+        result = divmod(left, right)
+
+        tm.assert_series_equal(result[0], expected[0])
+        tm.assert_series_equal(result[1], expected[1])
+
+        # rdivmod case
+        result = divmod(left.values, right)
+        tm.assert_series_equal(result[0], expected[0])
+        tm.assert_series_equal(result[1], expected[1])
+
+    def test_ser_divmod_inf(self):
+        left = pd.Series([np.inf, 1.0])
+        right = pd.Series([np.inf, 2.0])
+
+        expected = left // right, left % right
+        result = divmod(left, right)
+
+        tm.assert_series_equal(result[0], expected[0])
+        tm.assert_series_equal(result[1], expected[1])
+
+        # rdivmod case
+        result = divmod(left.values, right)
+        tm.assert_series_equal(result[0], expected[0])
+        tm.assert_series_equal(result[1], expected[1])
+
     def test_rdiv_zero_compat(self):
         # GH#8674
         zero_array = np.array([0] * 5)
@@ -662,7 +710,9 @@ def test_modulo2(self):
             result2 = p["second"] % p["first"]
             assert not result.equals(result2)
 
-            # GH#9144
+    def test_modulo_zero_int(self):
+        # GH#9144
+        with np.errstate(all="ignore"):
             s = Series([0, 1])
 
             result = s % 0

pandas/tests/sparse/series/test_series.py

@@ -578,6 +578,7 @@ def check(a, b):
             _check_op(a, b, lambda x, y: operator.floordiv(y, x))
             _check_op(a, b, lambda x, y: operator.mul(y, x))
 
+            # FIXME: don't leave commented-out
             # NaN ** 0 = 1 in C?
             # _check_op(a, b, operator.pow)
             # _check_op(a, b, lambda x, y: operator.pow(y, x))