如何将 **kwargs 传递给另一个具有更改该键值的函数?

Question

我有以下函数来计算激光束在腔体中的传播。它依赖于存储在称为core_data的字典中的许多参数，这是一个基本参数集。

def propagate(N, core_data, **ddata):
cd = copy.deepcopy(core_data)  # use initial configuration
cd.update(ddata)  # update with data I want to change
cavity = get_new_cavity(cd)  # get new cavity object
P = []
for i in range(N):
cavity.evolve(1)
P.append(cavity.get_power())
return P

如果我想更改参数并查看它对激光的影响，我可以调用该函数，例如

P0 = propagate(1000, core_data, L1=1.2, M5=17)

这效果很好。

现在，我将编写一个函数，将这个函数传递给ProcessPoolExecutor，并使用相同的键迭代**ddata的值。例如，它应该像这样工作(更简单的示例)：

propagate_parallel(1000, core_data,
L1=np.linspace(1, 2, 2),
M5=np.linspace(16, 17, 2))

然后应该并行执行此操作：

propagate(1000, core_data, L1=1, M5=16)
propagate(1000, core_data, L1=1, M5=17)
propagate(1000, core_data, L1=2, M5=16)
propagate(1000, core_data, L1=2, M5=17)

这样的东西适用于我的情况：

xrng = np.linspace(110e-30, 150e-30, Nx)
yrng = np.linspace(6.6e-9, 6.7e-9, Ny)
futures = []
with confu.ProcessPoolExecutor(max_workers=Ncores) as pool:
for y, x in it.product(yrng, xrng):
futures.append(pool.submit(propagate, RTs=1000,
core_data=core_data,
gdd_dm=x, dwl_filt=y))

问题是这并不灵活，我无法将其放入一个不错的功能中，如上所述。它应该是一个可以像这样调用的函数，以从上面重现代码：

propagate_parallel(1000, core_data, gdd_dm=xrng, dwl_filt=yrng)

如何使用相应键的迭代值从**ddata传递键？

仅供参考，我使用了：

import numpy as np
import concurrent.futures as confu
import itertools as it

Answer 1

您正在寻找对笛卡尔乘积的迭代。

这是一种遍历笛卡尔的方法。

from itertools import product
import numpy as np
L1=np.linspace(1, 2, 2)
M5=np.linspace(16, 17, 2)
dconf = dict(data=5)
size = L1.size
loop_size = size**2
def propagate(N, data, modifiers):
data.update(modifiers)
out = []
for i in range(N):
out.append('%s : %s : %s : %s'%(i, *data.values()))
return out
mod = (dict(L1=i, M5=j) for i, j in product(L1, M5))
m = map(propagate, np.arange(2, 2+loop_size), (dconf,)*loop_size, mod)
for outer in m:
for inner in outer:
print(inner)

这可以适应你的代码，如果你真的需要并行(这意味着在内核之间拆分信息)，也许可以看看 Dask。

希望这足以让你继续前进。

编辑： 你的问题很难真正确定。 您的问题真的是如何实现简单的"函数调用"吗？ 我想一个答案只是制作一个包装函数，比如......

def propagate(N, data, modifiers):
...
def call_propagate(N, data, L1_, M5_):
mod = ...
m = map(...
return m
for outer in call_propagate(1000, dconf, L1, M5)
for inner in outer:
print(inner)

Answer 2

我想我以某种方式被阻止了...我一直在想如何保留一个变量名(用于 instannceL1)并将其作为变量传递给另一个函数。

@ahead87：你的第一句话已经解开了我的障碍，我意识到**data可以通过字典简单地处理。所以，最后，我只需要将输入字典转换为下一个函数的字典列表，就像这样(剪掉一些不相关的部分)：

def propagate_parallel(RTs, cav_data, **ddata):
keys = list(ddata.keys())
values = list(ddata.values())
futures = []
res = []
with confu.ProcessPoolExecutor(max_workers=32) as pool:
for i in it.product(*values):
futures.append(pool.submit(propagate, RTs=RTs,
cav_data=cav_data,
**dict(zip(keys, list(i)))))
for fut in futures:
res.append(fut)
return res

最后，我想我终于明白了**kwargs，它可以作为字典来处理。 谢谢！