Is it worthy to create a wrapper function like this? I have a few Python codes like this:

 workflow = [] 
 conf = {}
 result = []
 prepare_A(workflow, conf)
 prepare_B(workflow, conf)
 prepare_C(workflow, conf)
 result.append(prepare_D_result(workflow, conf))
 prepare_E(workflow, conf)
 #.... about 100 prepare functions has the same parameter list


I was wondering that whether I need to rewrite like this:

 workflow = [] 
 conf = {}
 result = []
 def prepare_wrapper(prepare_function):
         return prepare_function(workflow, conf)

 prepare_wrapper(prepare_A)
 prepare_wrapper(prepare_B)
 prepare_wrapper(prepare_C)
 result.append(prepare_wrapper(prepare_D_result))
 prepare_wrapper(prepare_E)
 #.... about 100 prepare functions has the same parameter list


Though it might reduce the burden of passing 2 parameters into the function each time, it might bring difficulties for those who read codes. Is there better ways to ameliorate the code quality in such situation?
Here's an idea, assuming your logic is really that straightforward:

workflow = [] 
conf = {}
result = []

steps = ((prepare_A, False),
         (prepare_B, False),
         (prepare_C, False),
         (prepare_D, True),
         (prepare_E, False))

for func, need_results in steps:
    res = func(workflow, conf)
    if need_results:
        result.append(res)


If you don't find that approach suitable, I'd suggest making your wrapper a class that encapsulates workflow and conf, and possibly results too.

class PrepareWrapper(object):
    def __init__(self):
        self.workflow = [] 
        self.conf = {}

    def __call__(self, prepare_function):
         return prepare_function(self.workflow, self.conf)        

prepare_wrapper = PrepareWrapper()         
prepare_wrapper(prepare_A)  
prepare_wrapper(prepare_B)  


Or, why not make all the prepare functions methods of this class?