python - 一种将循环打包到函数中以使变量静音的 pythonic 方法？

Question

我不确定我应该说多详细，所以如果这太简洁请要求详细说明。

有没有办法将 for a,b,c in product(d['a'],d['b'],d['c']): 打包成一些语法糖，所以我只需要为这个循环本身键入一次静音变量 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，需要为某些列表的笛卡尔积的每个单元格调用它。我正在使用 product 函数来避免嵌套循环。假设我们有一个 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)
...

补充:我已经简化了一些事情，但令我惊讶的是，究竟哪里潜伏着歧义:-)

感谢您到目前为止的所有回答!

使用 dproduct 包装器是一个很好的建议。我确实有一个，只是不想抢占你的建议。

变量名对于代码逻辑来说是无意义的，但是为了代码的维护，它们还是有一些意义的。所以他们不能每个都由一个字母组成。

为了进一步澄清:我想避免三次使用变量名称 - 在“for ...”部分、对 dproduct 包装器的调用和 API 调用中。两次 - 在对包装器的调用和 API 调用中是正常的，因为它反射(reflect)了逻辑。

下面是我现在拥有的代码的一个更详细的示例。

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)

Answer 1

首先，您可以像这样编写一个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 — 或者，如果您不介意被 hacky:

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] 来加快速度然后在内部循环中每次都使用 zip(calls, argcounts) 而不是使用 inspect。)

---

无论如何，在不了解你的程序的情况下，很难准确地说出你能做什么，你应该做什么——这些想法中的大多数通常都不是很 Pythonic，即使它们在某些特殊的不寻常的情况下可能有用.

但无论哪种方式，它们都应该作为您可以轻松完成的事情的示例，而不必陷入涉及 locals 和 globals 或 getframe.