speed of Python function with dict/numpy array input

The timing discrepancy you're observing is because:

1. You made a simple mistake: You defined a default dict/array for these functions, but then recreated it again for every call rather than letting the default get used, so the defaults didn't save you anything, and recreating the dict/arrays for each call involved extra pointless work.
2. Even if you weren't recreating the arguments for no reason, accessing function local variables (including parameters), under CPython is, under-the-hood, roughly equivalent to a simple C array access (just loading a value at an offset from a low-level pointer). Accessing your dict or numpy.array has the same fairly trivial local variable lookup overhead (to load pars each time) plus additional overhead to perform a key or index lookup (which is meaningfully more costly than local variable lookup, and you do it many times per call).

The only way to get the dict version to work at the same speed would be to use said dict to dynamically generate the named parameters version of the function (e.g. create the function definition as a string from the dict, then compile+eval or exec it to compile the function up front†). dict lookups are strictly slower than local variable lookups. There are some optimizations in more modern CPython (3.9 is quite old at this point, not sure why you haven't upgraded) that reduce the overhead of read-only access to dicts in specific cases by using a per-op-code cache, but the benefits of that are largely limited to the hidden dicts involved in attribute, global, and built-in lookup, not explicit use of dicts.

I'm not sure why you think it's cleaning up the arguments to have a separate function that makes a dict with the same values, and prevents callers from replacing the defaults individually at call time, instead requiring them to construct and modify a dict or array to pass in. I might suggest making your defaulted arguments keyword-only (there are enough of them that attempts to pass them positionally are likely to make mistakes, and make the calling code harder to maintain when it's not clear what arguments are being passed). To do this, just add a * in the parameter listing, and perhaps break up the arguments visually into related groups per line (a single argument per-line, regardless of grouping, is also a reasonable option), e.g.:

def namedargs(Ep, Eq,
              *,
              a=0.16, b=0.18,
              F0=0.12,
              s=0.0,
              eps=3.0e-3,
              V=3.0,
              p0=0.5, p10=0.956,
              q0=0.1, q10=0.306):

Now callers will have to be explicit about passing a vs. b vs. s, making maintenance easier, and the parameters, while verbose, are fairly readable in the source code.

†Per your request, dynamically generating a function using get_par_default and a template string:

def get_par_default():
    return {'a':0.16, 'b':0.18, 'F0':0.0, 's':0.0, 'eps':3.0e-3, 'V':3.0,
            'p0':0.30575896, 'p10':0.48998486, 'q0':0.06468597, 'q10':0.27093151}

eval(compile(f'''
def dynnamedargs(Ep, Eq, *, {', '.join(f"{k}={v!r}" for k, v in get_par_default().items())}):
    """I only exist thanks to dynamic code-generation"""
    ans = Ep*Eq*a*b*F0*s*eps*V*p0*p10*q0*q10
    return ans
''', __file__, 'exec'))

help(dynnamedargs)

Try it online!

which, by using help to display information about the compiled function, outputs:

Help on function dynnamedargs in module __main__:

dynnamedargs(Ep, Eq, *, a=0.16, b=0.18, F0=0.0, s=0.0, eps=0.003, V=3.0, p0=0.30575896, p10=0.48998486, q0=0.06468597, q10=0.27093151)
    I only exist thanks to dynamic code-generation

demonstrating that the generated function has defaults derived from the dict produced by get_par_default, but is not runtime reliant on such a dict. If you call it, given it's a garbage implementation that multiplies all its arguments, it will always return zero or NaN I believe (and I'm not sure about the latter), but you could pass it non-default values for individual arguments as normal for keyword arguments, and demonstrate it's working normally, e.g.:

print(dynnamedargs(12, 10, F0=1, s=12.4, eps=5))

outputs:

1.6877889687359113

To explain what's happening, I just used a trivial triple-quoted f-string as the template (with the first line blank so I could align the def visually with the rest of template code; if you want the whole string indented because it's being defined in a nested context, inspect.cleandoc is useful for stripping off common leading whitespace to avoid syntax errors), and generated the actual string of arguments and their defaults in it single placeholder. Note that I used !r to coerce the values to their repr form; it's not necessary here, since float and int have identical str and repr forms, but you want to be in the habit to avoid mistakes if one of the arguments has a str form that is "human-friendly" and doesn't constitute valid Python code, e.g. because the default is in fact a str, which wouldn't be quoted or escaped unless converted to repr form; reprs are usually valid Python code by convention.

compile is just converting from string to compiled code, and by passing __file__ it will act as if it were defined in this file. exec mode means it can be composed of complex and/or multiple statements. Once compiled, eval then actually executes the compiled code, defining the function (since I passed no other arguments, it's defined in the current scope, which is global).