一種自動將參數傳遞給函數的方法？

Question

我有一堆模塊中的回調函數。他們都呼籲some_func()與第一個，比方說，兩個參數總是相同的，並從他們自己的論據中派生出來，而其他論點各不相同。像這樣：

from outer.space import some_func 
def callback_A(param1, param2, param3): 
    ... 
    some_func(param2+param1, param3, ..., ...) 
    ... 

def callback_B(param1, param2, param3, param4): 
    ... 
    some_func(param2+param1, param3, ..., ...) 
    ... 

而且它遍佈整個代碼。而且比param2 + param1更醜陋。

在C/C++，我只是做了宏觀

#define S_F(a,b) some_func(param2+param1, param3, a, b) 

，並開始使用S_F內的回調，而不是some_func。我可以在Python中做什麼？

Answer 1

您可以使用functools.partial

>>> from functools import partial 
>>> def my_function(a,b,c,d,e): 
...  print (a,b,c,d,e) 
... 
>>> func_with_defaults = partial(my_function, 1, 2, e=5) 
>>> func_with_defaults(3, 4) 
(1, 2, 3, 4, 5) 

編輯：

既然你不提前擁有這些價值，你不能使用partial或lambda。 你可能會想這樣做：

>>> A = lambda x: x + y 
>>> def do_something(y): 
...  return A(2) # hope it uses the `y` parameter... 
... 
>>> do_something(1) 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
    File "<stdin>", line 2, in do_something 
    File "<stdin>", line 1, in <lambda> 
NameError: global name 'y' is not defined 

但你可以看到這是行不通的。爲什麼？因爲當你定義一個函數時，python會保存你定義它的範圍，並用它來解決變量。

如果你有機會訪問some_func將有可能給你想要做什麼用「黑客」利用inspect解釋堆棧但這不是做一個強大的也不優雅的事情，所以做不做到這一點。

我想你的情況做的就是重寫聲明。

如果你真的想避免這種情況，你可以使用exec試一下：

>>> def some_function(a,b,c): 
...  print(a,b,c) 
... 
>>> code = 'some_function(a+b,c,%s)' 
>>> 
>>> def func_one(a,b, c): 
...  exec code % 1 
... 
>>> def func_two(a,b,c): 
...  exec code % 2 
... 
>>> func_one(1,2,3) 
(3, 3, 1) 
>>> func_two(1,2,3) 
(3, 3, 2) 

但這醜陋。

如果你只使用位置參數給你的函數，你可以做一些更優雅如：

>>> def compute_values(a,b,c): 
...  return (a+b, c) 
... 
>>> def func_one(a,b,c): 
...  some_function(*(compute_values(a,b,c) + (1,))) 
... 
>>> def func_two(a,b,c): 
...  some_function(*(compute_values(a,b,c) + (2,))) 
... 
>>> func_one(1,2,3) 
(3, 3, 1) 
>>> func_two(1,2,3) 
(3, 3, 2) 

但在這一點上你只是重複一個不同的文本，而你失去了很多的可讀性。 如果你想在Python中有預處理功能，你可以嘗試Python Preprocessing，儘管在你的情況下，我寧願重複函數調用。

Answer 2

S_F = lambda a, b: some_func(param2+params1, param3, a, b) 

記住param1，param2和param3必須在lambda語句的範圍內都有效，就像some_func。

Answer 3

如何與keyword arguments而不是函數簽名的位置參數：

some_func(**kwargs): 
    Instead of position arguments, just use the keys that some_func can respond to. 
    You can defaults to the ones not included... 
    if key1 in kwargs: 
     #use key1... 
    #... 

def callback_A(param1, param2, param3): 
    some_func(key1=param1+parma2,key2=param3, other_key=...) 


def callback_B(param1, param2, param3, param4): 
    some_func(key1=param2+param1, key2=param3, other_keys=..., ...) 

---

編輯

如果你不能改變函數簽名some_func那麼你可以把它包裝：

def some_func(a,b,c,d,e): 
    print 'some_funct({}, {}, {}, {}, {})'.format(a,b,c,d,e) 

def some_func_wrap(**kwargs): 
    params={'p1':'default a','p2':'default b', 
       'p3':'default c','p4':'default d','p5':'default e'} 
    for p,arg in kwargs.items(): 
     try: 
      del params[p] # to raise an error if bad key 
      params[p]=arg 
     except KeyError: 
      print 'bad param to some_func_wrap()\n' 
      raise 

    some_func(*[params[k] for k in sorted(params.keys())]) 

some_func_wrap(p1=1,p2=1+3) 

個

打印：some_funct(1, 4, default c, default d, default e)

Answer 4

你可以將它基於裝飾：

import functools 
from outer.space import some_func 

def with_some(f): 
    @functools.wraps(f) 
    def wrapper(param1, param2, param3, *args): 
     new_args = f(*args) 
     return some_func(param1+param2, param3, *new_args) 

    return wrapper 

@with_some 
def callback_A(): 
    return() # Will call some_func(param1 + param2, param3) 

... 

@with_some 
def callback_B(param4): 
    return param4, # some_func(param1 + param2, param3, param4) 

包裹的功能都將有簽名f(param1, param2, param3, *args)