Question

我正在尝试使用solve_ivp解决大型微分方程组。

from scipy import integrate
sol = integrate.solve_ivp(func_system, (0,100), initial_value_array, t_eval)

func_system是一个微分方程组，它取决于列表X的长度：

X = ['a','b','c','d',...]

K1, K2, K3, K4 = [1, 2, 2, 1]

def dadt(X,t):
    return -K1*X[0]+K2*X[1]
def dbdt(X,t):
    return K2*X[0]-(K2+K3+K4)*X[1]
def dcdt (X,t):
    return ....
def dddt (X,t):
    return ....

以此类推。

def func_system(X,t):
    return np.array([dadt(X,t), dbdt(X,t), dcdt(X,t), dddt(X,t)])

因为X可能很长，所以我想遍历列表以创建函数名称。例如，

dxdt = ['d'+a+'dt' for a in X]

for i in range(len(dxdt)):
    def dxdt[i]:
        return something

，从数据帧中获取“内容”。我的问题是是否可以遍历列表以创建函数名称？

Answer 1

这是您要完成的事情吗？

Python 3.6.9 (default, Oct 17 2019, 06:42:36) 
Type 'copyright', 'credits' or 'license' for more information
IPython 7.2.0 -- An enhanced Interactive Python. Type '?' for help.

In [1]: X = ['a','b','c','d']                                                                                                                                                                                                              

In [2]: K1, K2, K3, K4 = [1, 2, 2, 1]                                                                                                                                                                                                      

In [3]: code = ['def d{symbol}dt(X, t): return "something"'.format(symbol=symbol) for symbol in X]                                                                                                                                         

In [4]: functions = {}                                                                                                                                                                                                                     

In [5]: for func in code: 
   ...:     exec(func, {}, functions) 
   ...:                                                                                                                                                                                                                                    

In [6]: functions                                                                                                                                                                                                                          
Out[6]: 
{'dadt': <function dadt(X, t)>,
 'dbdt': <function dbdt(X, t)>,
 'dcdt': <function dcdt(X, t)>,
 'dddt': <function dddt(X, t)>}

In [7]: functions['dadt'](1, 0)                                                                                                                                                                                                            
Out[7]: 'something'

Answer 2

正如已经建议的，您可以简单地使用eg。字典来做到这一点。如果所有功能共享相同的签名，

，这不是最优雅的解决方案，但绝对可行，甚至也不难看。

dispatch = {
  'dadt': lambda X, t: -K1*X[0]+K2*X[1],
  'dbdt': lambda X, t: K2*X[0]-(K2+K3+K4)*X[1],
  # you get the idea
}

# later, eg. to call dadt(my_vector, t):
rval = dispatch["dadt"](my_vector, t)

# or, if you want to have pretty functions eg. that you call often, functions
# are just values too:

dadt = dispatch["dadt"]
dadt(my_vector, t)

Answer 3

为什么不使用dict？键将是名称和值函数。

遍历列表以创建函数

3 个答案: