将循环打包成一个函数来静音变量的pythonic方法？
我不确定我应该走多远，所以如果这太简单了，请详细说明。
有没有办法将产品中的for a,b,c in product(d['a'],d['b'],d['c']):打包for a,b,c in product(d['a'],d['b'],d['c']):在某些语法糖中，所以我只需要键入mute变量a,b,c对于这个循环本身只有一次？
像这样的东西可能是？
my_for_loop('a','b','c'):
API_Call1(a)
API_Call2(b,c)
代替
for a,b,c in product(d['a'],d['b'],d['c']):
API_Call1(a)
API_Call2(b,c)
my_for_loop怎么样？ 我在概念上如何解决这个问题上有点失落。
更多详情：
我有一个API，需要为某些列表的笛卡尔积的每个单元调用它。 我正在使用产品功能来避免嵌套循环。 假设我们有一个list1和一个list2，它可以通过以下方式完成
from itertools import product
for a,b in product(list1,list2):
API_Call(a,b)
我已经创建了一个dictionary_of_lists={'a':list1,'b':list2,'c':list3...}能够像这样写出来
for a,b in product(dictionary_of_lists['a'],dictionary_of_lists['b']):
API_Call(a,b)
for c,b in product(dictionary_of_lists['c'],dictionary_of_lists['b']):
API_Call(c,b)
for e,f,g,h in product(dictionary_of_lists['e'],dictionary_of_lists['f'],dictionary_of_lists['g'],dictionary_of_lists['h'],):
API_Call1(e,f,g,h)
API_Call2(e,h)
...
因此，基本上，循环创建的变量在该API调用中使用，并且它们是静音的，否则它们的名称无关紧要。 这些电话有很多，他们周围有一些令人费解的逻辑。 所以我想保持循环本身简单，并且我需要更改变量，我不必在三个地方为每个这样的循环更改它们。
my_for_loop('a','b'):
API_Call(a,b)
my_for_loop('b','c'):
API_Call(c,b)
my_for_loop('e','f','g','h'):
API_Call1(e,f,g,h)
API_Call2(e,h)
...
附加：我简化了一些事情，但惊讶地发现模糊不清的地方潜伏着:-)
感谢迄今为止所有的答案！
这是一个很好的建议，有产品包装。 我确实有一个，只是不想抢占你的建议。
变量名称对于代码逻辑是静音的，但为了维护代码，它们有一些含义。 所以他们不能由一个字母组成。
为了进一步澄清：我想避免使用变量名称三次 - 在“for ...”部分中，在调用dproduct包装器和API调用中。 两次 - 在调用封装器和API调用时是OK的，因为它反映了逻辑。
下面是我现在的代码更详细的例子。
def dproduct(d, keys):
subset_d = dict((k, d[k]) for k in keys if k in d)
return product(*[subset_d.values()])
for foo, bar in dproduct(d, ['foo','bar',]):
some logic here
if API_Call1(foo,bar) == 123:
some other stuff, API_Call6(quux,baz,)
some more stuff and a call to another dproduct
for quux, sl, baz in dproduct(d, ['quux','sl','baz',]):
blah blah, API_Call2(quux,sl,baz)
other stuff
for pa, mf in dproduct(d, ['pa','mf',]):
API_Call4(pa,mf)
for quux, sl, baz in dproduct(d, ['quux','sl','baz',]):
further logic
if API_Call1(quux, sl, baz) == 342: some other stuff
some more stuff and a call to another dproduct
for pa,mf in dproduct(d, ['pa','mf',]):
API_Call3(pa,mf)
你不能轻易地将变量插入本地命名空间（可能可以但不应该没有好的原因）。 所以用一个字典来保存你的命名值。
我使用了operator.itemgetter函数来获取各种API调用所需的函数，并将产品函数包装在生成器中。
from operator import itemgetter
from itertools import product
class DictCaller(dict):
def __call__(self, fn, *args):
fn(*map(itemgetter(self), args))
def my_product(d, *args):
for xs in product(*map(itemgetter(d), args)):
yield DictCaller(zip(args, xs))
for caller in my_product(*'abc'):
caller(API_CALL, *'ab')
caller(API_CALL1, *'bc')
首先，你可以写这样的product包装：
def dproduct(d, keys):
return product(*(d[key] for key in keys))
for a, b, c in dproduct(d, 'abc'):
API_Call1(a)
API_Call2(b, c)
（请注意，您可以使用operator.itemgetter而不是genexpr编写相同的内容;这取决于您发现哪些内容更具可读性。）
当然，我正在利用这样一个事实，即所有的密钥都有单字符名称，并且字符串是其字符的迭代。 如果你的真实姓名不是单个字符，你必须稍微冗长：
for a, b, c in dproduct(d, ('spam', 'eggs', 'beans')):
...在这一点上，你可能想考虑在args中使用*args而不是参数 - 或者，如果你不介意使用哈希：
def dproduct(d, keys):
return product(*(d[key] for key in keys.split()))
for a, b, c in dproduct(d, 'spam eggs beans'):
然后，您可以走得更远，也可以围绕您的通话写封皮。 例如，如果您生成值的字典而不是值的元组，您可以像我们使用列表的原始字典一样使用这些字典：
def dproduct(d, keys):
for vals in product(*(d[key] for key in keys)):
yield dict(zip(keys, vals))
def call1(d, keys):
return API_Call1(*(d[key] for key in keys))
def call2(d, keys):
return API_Call2(*(d[key] for key in keys))
for vals in dproduct(d, 'abc'):
call1(vals, 'a')
call2(vals, 'bc')
或者，如果您的API_Call*函数可以使用关键字而不是位置参数，则可以使事情变得简单和清晰：
def dproduct(d, keys):
for vals in product(*(d[key] for key in keys)):
yield dict(zip(keys, vals))
def dselect(d, keys):
return {key: d[key] for key in keys}
for vals in dproduct(d, 'abc'):
API_Call1(**dselect(vals, 'ab'))
API_Call2(**dselect(vals, 'c'))
如果你不能使用关键字参数，并且你有很多API_Call*函数，你可以进一步去动态生成包装器：
def apiwrap(apicall):
@functools.wraps(apicall)
def wrapper(d, keys):
return apicall(*(d[key] for key in keys))
return wrapper
apicall1 = apiwrap(API_Call1)
apicall2 = apiwrap(API_Call2)
# etc.
虽然如果你有很多这样的东西，你可能想把它们放在一个列表或一个字典中......
如果你想得到太聪明的方法，你甚至可以根据API函数的签名动态分解元组：
def dispatch(d, keys, *calls):
for vals in product(*(d[key] for key in keys)):
it = iter(vals)
for call in calls:
args = islice(it, len(signature(call).parameters))
call(*args)
dispatch(d, 'abc', API_Call1, API_Call2)
（如果你的函数体非常小，你可能想通过在argcounts = [len(signature(call).parameters for call in calls]执行argcounts = [len(signature(call).parameters for call in calls]来加快速度，然后使用zip(calls, argcounts)而不是每次在内部循环中使用inspect 。）
无论如何，在不了解更多关于你的程序的情况下，很难准确地说出你能做什么，以及你应该做什么 - 这些想法大多不是Pythonic，尽管它们在某些特殊情况下可能有用。
但无论哪种方式，它们都应该成为您可以轻松完成的事情的示例，而不必陷入涉及locals和globals或getframe可怕黑客getframe 。
上一篇: A pythonic way of packing loops into a function to mute variables?