Question

我正在尝试使用递归函数来简化“ for-loops”下面的“ for-loops”，以便根据需要运行程序的任何数量的循环。我可以在函数中不使用i，j，k，l ...的情况下定义递归函数，但我不知道，或者在使用i，j k定义迭代函数时遇到困难。。如果有人可以帮助我一点点想像，我会很高兴。

adjcent_spin_product_matrix = []
z_partial = 0
spin = [-1, 1]
for i in spin:
    for j in spin:
        for k in spin:
            for l in spin:
               for m in spin:
                   for o in spin:
                       for p in spin:
                           adjcent_spin_product_matrix = adjcent_spin_product_matrix + [i*j+ j*k+ k*l+ l*n+ m*o+ o*p]

Answer 1

我先前的回答是针对您未编辑的帖子，所以这里有更新：

根据您提供的代码，很显然，您必须至少具有i和j的循环。

单独评估该循环将给出以下列表： [1, -1, -1, 1]

现在，您编码中的每个后续嵌套循环仅复制此列表中的每个元素，然后添加上一个循环中的数组（重复两次）：

第i，j和k个循环给出[1, 1, -1, -1, -1, -1, 1, 1] + [1, -1, -1, 1, 1, -1, -1, 1] = [2, 0, -2, 0, 0, -2, 0, 2]

第i，j，k和l个循环给出[1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1] + [1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, 1, 1] + [1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1] = [3, 1, -1, 1, -1, -3, -1, 1, 1, -1, -3, -1, 1, -1, 1, 3]

依此类推...

因此，您可以简单地尝试以下操作：

adjacent_spin_product_matrix = []
ij_result = [1, -1, -1, 1]

def calc_product(adjacent_spin_product_matrix, number_of_indices):
    if number_of_indices == 2:
        return ij_result
    else:
        number_of_duplicates = 2 ** (number_of_indices - 2)
        curr_array = []
        for elem in ij_result:
            for dup in range(number_of_duplicates):
                curr_array.append(elem)
        prev_array = calc_product(adjacent_spin_product_matrix, number_of_indices - 1)
        temp_array = []
        temp_array.extend(prev_array)
        temp_array.extend(prev_array)
        result = []
        for i, elem in enumerate(curr_array):
            result.append(elem + temp_array[i])

        return result

现在，您应该会发现：

print(calc_product([], 2))  # equivalent to i and j case
print(calc_product([], 3))  # equivalent to i, j, and k case
print(calc_product([], 4))  # equivalent to i, j, k, and l case
print(calc_product([], 5))  # equivalent to i, j, k, l, and m case
print(calc_product([], 6))  # equivalent to i, j, k, l, m, and o case
print(calc_product([], 7))  # equivalent to i, j, k, l, m, o, and p case

这些给出了预期的结果：

[1, -1, -1, 1]
[2, 0, -2, 0, 0, -2, 0, 2]
[3, 1, -1, 1, -1, -3, -1, 1, 1, -1, -3, -1, 1, -1, 1, 3]
[4, 2, 0, 2, 0, -2, 0, 2, 0, -2, -4, -2, 0, -2, 0, 2, 2, 0, -2, 0, -2, -4, -2, 0, 2, 0, -2, 0, 2, 0, 2, 4]
[5, 3, 1, 3, 1, -1, 1, 3, 1, -1, -3, -1, 1, -1, 1, 3, 1, -1, -3, -1, -3, -5, -3, -1, 1, -1, -3, -1, 1, -1, 1, 3, 3, 1, -1, 1, -1, -3, -1, 1, -1, -3, -5, -3, -1, -3, -1, 1, 3, 1, -1, 1, -1, -3, -1, 1, 3, 1, -1, 1, 3, 1, 3, 5]
[6, 4, 2, 4, 2, 0, 2, 4, 2, 0, -2, 0, 2, 0, 2, 4, 2, 0, -2, 0, -2, -4, -2, 0, 2, 0, -2, 0, 2, 0, 2, 4, 2, 0, -2, 0, -2, -4, -2, 0, -2, -4, -6, -4, -2, -4, -2, 0, 2, 0, -2, 0, -2, -4, -2, 0, 2, 0, -2, 0, 2, 0, 2, 4, 4, 2, 0, 2, 0, -2, 0, 2, 0, -2, -4, -2, 0, -2, 0, 2, 0, -2, -4, -2, -4, -6, -4, -2, 0, -2, -4, -2, 0, -2, 0, 2, 4, 2, 0, 2, 0, -2, 0, 2, 0, -2, -4, -2, 0, -2, 0, 2, 4, 2, 0, 2, 0, -2, 0, 2, 4, 2, 0, 2, 4, 2, 4, 6]

Answer 2

如果您不想使用递归函数来执行此操作，则可以使用stack。将循环的每个级别推入堆栈，以便稍后将其弹出。

栈是大多数语言中的基本数据结构，因为它是存储函数调用上下文的非常自然的方式，也是堆栈溢出的得主。

Answer 3

不需要递归函数。

如果使用itertools.product，则可以为每个索引数使用一个循环；您也可以使用sum和zip

简化计算

from itertools import product
...
spin_products = []
n = int(input('how many indices? '))
...
for indices in product([-1, 1], repeat=n):
    spin_products.append(sum(i*j for i, j in zip(indices, indices[1:])))

如何定义涉及for循环的迭代函数，其中在定义的迭代函数中也使用了迭代器i，j，l ..

3 个答案: