human
I wrote the below code

    def na_op(x, y):
        try:
            result = expressions.evaluate(op, str_rep, x, y, raise_on_error=True, **eval_kwargs)
        except TypeError:
            if isinstance(y, (np.ndarray, ABCSeries, pd.Index)):
                dtype = find_common_type([x.dtype, y.dtype])
                result = np.empty(x.size, dtype=dtype)
                mask = (notna(x) & notna(y))
                result[mask] = op(x[mask], _values_from_object(y[mask]))
            elif isinstance(x, np.ndarray):
                result = np.empty(len(x), dtype=x.dtype)
                mask = notna(x)
                result[mask] = op(x[mask], y)
            else:
                raise TypeError('{typ}    cannot    perform    the    operation    {op}'.format(typ=type(x).__name__, op=str_rep))
            (result, changed) = maybe_upcast_putmask(result, (~ mask), np.nan)
        result = missing.fill_zeros(result, x, y, name, fill_zeros)
        return result
    def safe_na_op(lvalues, rvalues):
        try:
            with np.errstate(all='ignore'):
                return na_op(lvalues, rvalues)
        except Exception:
            if isinstance(rvalues, ABCSeries):
                if is_object_dtype(rvalues):
                    return libalgos.arrmap_object(rvalues, (lambda x: op(lvalues, x)))
            elif is_object_dtype(lvalues):
                return libalgos.arrmap_object(lvalues, (lambda x: op(x, rvalues)))
            raise
    def wrapper(left, right, name=name, na_op=na_op):
        if isinstance(right, pd.DataFrame):
            return NotImplemented
        (left, right) = _align_method_SERIES(left, right)
        converted = _Op.get_op(left, right, name, na_op)
        (left, right) = (converted.left, converted.right)
        (lvalues, rvalues) = (converted.lvalues, converted.rvalues)
        dtype = converted.dtype
        wrap_results = converted.wrap_results
        na_op = converted.na_op
        if isinstance(rvalues, ABCSeries):
            name = _maybe_match_name(left, rvalues)
            lvalues =...

What's a good function header?

Here's a good function header?
assistant
#Here's a good function header.

def _arith_method_SERIES(op, name, str_rep, fill_zeros=None, default_axis=None, construct_result=_construct_result, **eval_kwargs):