如何将附加参数（除了参数）传递给 Python 中的函数

Question

I need to write a function (say fun1 ) that has one argument, because it will be used in other function ( fun2 ). The latter requires a function with a single argument. However, I need to pass other parameters to function fun1 . How can I do this in Python without using global variables? Or this is the only way?

Addition: If it is important, fun2 is some optimization function from scipy.optimize . Below is an example of passing additional parameter c to function fun1 using global . In the first call, function fun2 takes fun1 as x+1 , but in the second call, fun1 is x+2 . I would like to make similar, but without using global . Hopefully, the example clarifies the question. (The example is changed).

def fun1(x) :
   global c
   return  x + c

def fun2(f1, x) :
   return  f1(x)

# main program
global c
x0= 1  
c= 1;   y= fun2(fun1, x0);  print(y)    # gives 2
c= 2;   y= fun2(fun1, x0);  print(y)    # gives 3

Answer 1

If I've understood your question correctly, there are quite a number of ways to do what you want and avoid using global variables. Here they are.

Given:

x0 = 1
def fun2(f1, x):
    return f1(x)

All of these techniques accomplish your goal:

#### #0 -- function attributes
def fun1(x):
    return x + fun1.c

fun1.c = 1;  y = fun2(fun1, x0);   print(y)   # --> 2
fun1.c = 2;  y = fun2(fun1, x0);   print(y)   # --> 3

#### #1 -- closure
def fun1(c):
    def wrapper(x):
        return x + c
    return wrapper

y = fun2(fun1(c=1), x0);   print(y)   # --> 2
y = fun2(fun1(c=2), x0);   print(y)   # --> 3

#### #2 -- functools.partial object
from functools import partial

def fun1(x, c):
    return x + c

y = fun2(partial(fun1, c=1), x0);   print(y)   # --> 2
y = fun2(partial(fun1, c=2), x0);   print(y)   # --> 3

#### #3 -- function object (functor)
class Fun1(object):
    def __init__(self, c):
        self.c = c
    def __call__(self, x):
        return x + self.c

y = fun2(Fun1(c=1), x0);   print(y)   # --> 2
y = fun2(Fun1(c=2), x0);   print(y)   # --> 3

#### #4 -- function decorator
def fun1(x, c):
    return x + c

def decorate(c):
    def wrapper(f):
        def wrapped(x):
            return f(x, c)
        return wrapped
    return wrapper

y = fun2(decorate(c=1)(fun1), x0);   print(y)   # --> 2
y = fun2(decorate(c=2)(fun1), x0);   print(y)   # --> 3

Note that writing c= arguments wasn't always strictly required in the calls -- I just put it in all of the usage examples for consistency and because it makes it clearer how it's being passed.

Answer 2

The fact that that function can be called even without those other parameters suggests, that they are optional and have some default value. So you should use default arguments .

def fun1(foo, bar='baz'):
    # do something

This way you can call function fun1('hi') and bar will default to 'baz' . You can also call it fun1('hi', 15) .

If they don't have any reasonable default, you can use None as the default value instead.

def fun1(foo, bar=None):
    if bar is None:
        # `bar` argument was not provided
    else:
        # it was provided

Answer 3

What you are looking for is a method in a class.

you define a class, with a method fun1 and an instance variable c . it is accessed from anywhere using the . notation:

class A:
    def fun1(self, x):
        return x + self.c

Let's define fun2, for the example:

def fun2(f, p):
    return f(p)

We can now use ac it like you did with the global varaible c :

>>> a = A() # create an instance and initialize it
>>>         # "self.c" is undefined yet
>>>
>>> a.c = 1 # "self.c" will be 1
>>> fun2(a.fun1, 1)
2
>>> a.c = 2 # now "self.c" will be 2
>>> fun2(a.fun1, 1) # same arguments, different result
3

Here you can learn more about classes.

Answer 4

Just add the extra parameters with default values:

def fun1(param1, param2=None, param3=None):
    ...

Then you can call fun1 from fun2 like this:

def fun2():
    something = fun1(42)

And from somewhere else you can call it like this:

fun1(42, param2=60)

Answer 5

You may use the decorators to pass it the very decorators:

def jwt_or_redirect(fn):
  @wraps(fn)
  def decorator(*args, **kwargs):
    ...
    return fn(*args, **kwargs)
  return decorator

def jwt_refresh(fn):
  @wraps(fn)
  def decorator(*args, **kwargs):
    ...
    new_kwargs = {'refreshed_jwt': 'xxxxx-xxxxxx'}
    new_kwargs.update(kwargs)
    return fn(*args, **new_kwargs)
  return decorator

and the final function:

@jwt_or_redirect
@jwt_refresh
def home_page(*args, **kwargs):
  return kwargs['refreched_jwt']