Q:

pythonic way for function with loads of parameters and return values

I'm trying to run a simulation in Python. For this to work I need to define a number of parameters and derive some others from these. Using these I then call several functions that act on these parameters and return a certain result. Currently my code looks something like this
common(ai, bi, ..., hi):
    # calculations
    return ao, bo, ..., fo
func1(ai, bi, ..., xi):
    ao, bo, ..., fo = common(ai, bi, ..., hi)
    # calculations specific to func1
    return y
func1(ai, bi, ..., xi):
    ao, bo, ..., fo = common(ai, bi, ..., hi)
    # calculations specific to func2
    return z

ai = 0
bi = 1
...
xi = 2

print(func1(ai, bi, ..., xi))
print(func2(ai, bi, ..., xi))

where I abbreviated the parameter list etc with the ... and calculations are performed in the # calculations sections. 
I would prefer to call the functions using func1(di=2) and have the default value for all the others. This would however mean using named arguments, in which case I have to specify the default values twice (in func1 and in func2). I do not think **kwargs would work here since that would require passing in the default values explicitly. 
I have been toying with the compromise of passing a dictionary to the functions and setting the non-standard argument before passing it on. This makes the function call much harder to understand however, so I felt that there should be an easier way to do this.
Since the functions only consist of relatively long equations, I do not want to add characters to the variable names as would be required when storing them in a dictionary and just calling them from there. This makes reading the equations much more difficult.
My question is whether there is a pythonic way to solve this issue.

A:

You have two methods with the same type of arguments and return value, the only difference is process inside the functions, namely, they share the same interfaces and functionality.
You want an easy way to define the functions, without having to write default arguments or passing in dictionary many times.
It would be nice to use decorator or class inheritance.
Decorator enables you to define a factory method that returns functions like func1 or func2. The interface is only defined once using default arguments in decorator, returned functions differ in the process methods or core methods.
Class inheritance works similarly, but through method inheritance, it's more flexible and general.

