Python 迭代列表以创建函数

我正在尝试使用

solve\u ivp

求解一个大型微分方程组

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

函数系统是一个微分方程系统，它取决于列表的长度

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

---

，在这里我可以从数据帧中获取“某物”。我的问题是，是否可以通过迭代列表来创建函数名？

为什么不使用

dict

？键是名称和值函数。

为什么不使用

dict

？关键是名称和值函数。

这就是您试图实现的目标吗

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'

Python 3.6.9（默认值，2019年10月17日06:42:36）
有关详细信息，请键入“版权”、“信用”或“许可证”
IPython 7.2.0——一种增强的交互式Python。键入“？”以获取帮助。
在[1]中：X=['a'，'b'，'c'，'d']
[2]中：K1，K2，K3，K4=[1，2，2，1]
在[3]中：code=['defd{symbol}dt（X，t）：返回“something”。X中的符号的格式（symbol=symbol）
在[4]中：函数={}
In[5]：对于代码中的func：
…：exec（func，{}，函数）
...:                                                                                                                                                                                                                                    
在[6]中：函数
出[6]：
{'dadt'：，
“dbdt”：，
“dcdt”：，
'dddt'：}
在[7]中：函数['dadt']（1,0）
Out[7]：“某物”

这就是你想要实现的目标吗

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'

Python 3.6.9（默认值，2019年10月17日06:42:36）
有关详细信息，请键入“版权”、“信用”或“许可证”
IPython 7.2.0——一种增强的交互式Python。键入“？”以获取帮助。
在[1]中：X=['a'，'b'，'c'，'d']
[2]中：K1，K2，K3，K4=[1，2，2，1]
在[3]中：code=['defd{symbol}dt（X，t）：返回“something”。X中的符号的格式（symbol=symbol）
在[4]中：函数={}
In[5]：对于代码中的func：
…：exec（func，{}，函数）
...:                                                                                                                                                                                                                                    
在[6]中：函数
出[6]：
{'dadt'：，
“dbdt”：，
“dcdt”：，
'dddt'：}
在[7]中：函数['dadt']（1,0）
Out[7]：“某物”

如前所述，您可以简单地使用例如dict来实现这一点。不是最优雅的解决方案，但绝对可行，即使所有函数共享相同的签名，也没有那么难看：

dispatch={
“dadt”：λX，t:-K1*X[0]+K2*X[1]，
“dbdt”：λX，t:K2*X[0]-（K2+K3+K4）*X[1]，
#你明白了吗
}
#稍后，例如调用dadt（我的向量，t）：
rval=调度[“dadt”]（我的向量，t）
#或者，如果你想拥有一些漂亮的函数，比如你经常调用的函数
#也只是价值观：
dadt=调度[“dadt”]
dadt（我的向量，t）

如前所述，您可以简单地使用例如dict来实现这一点。不是最优雅的解决方案，但绝对可行，即使所有函数共享相同的签名，也没有那么难看：

dispatch={
“dadt”：λX，t:-K1*X[0]+K2*X[1]，
“dbdt”：λX，t:K2*X[0]-（K2+K3+K4）*X[1]，
#你明白了吗
}
#稍后，例如调用dadt（我的向量，t）：
rval=调度[“dadt”]（我的向量，t）
#或者，如果你想拥有一些漂亮的函数，比如你经常调用的函数
#也只是价值观：
dadt=调度[“dadt”]
dadt（我的向量，t）

哦，来吧！我现在尝试了10分钟来更改函数对象的name属性。我是如此的冷漠