python嵌套循环递归怎么相加,python - 如何编写许多嵌套的“for”循环(递归)

word = "word"

# Splitting word into its characters

newword = []

for char in word:

newword.append(char)

print newword

#getting all permutations

test= []

for i in newword:

for j in newword:

if i != j:

for k in newword:

if j != k and i!= k:

for l in newword:

if i != l and j != l and k != l:

test.append(i+j+k+l)

print test

print type(test)

print len(test)

这4个嵌套循环对“word”很好，因为其中正好有4个字母。

如果我想要的“for”循环和任何给定单词中的字母一样多，我该怎么做？

有什么好把戏吗？

最佳答案

这是您试图解决的一般递归问题。itertools已经包含了几乎所有可能需要的实现的函数。但是，如果你想了解一些东西，这是一种方法。我将排列一个数字表。在这种情况下，我将找到下列排列：[0,1,2, ... ,N-1]

注意，一旦有了上面的排列，就可以简单地将它们用作排列任何内容的索引。那么，一般的做法是什么？

让我们先看一个具体案例的结果。对于say[0,1,2,3]的情况。我们正在寻找的结果是列表列表：

[[0, 1, 2, 3], [0, 1, 3, 2], [0, 2, 1, 3], [0, 2, 3, 1], [0, 3, 1, 2],

[0, 3, 2, 1], [1, 0, 2, 3], [1, 0, 3, 2], [1, 2, 0, 3], [1, 2, 3, 0],

[1, 3, 0, 2], [1, 3, 2, 0], [2, 0, 1, 3], [2, 0, 3, 1], [2, 1, 0, 3],

[2, 1, 3, 0], [2, 3, 0, 1], [2, 3, 1, 0], [3, 0, 1, 2], [3, 0, 2, 1],

[3, 1, 0, 2], [3, 1, 2, 0], [3, 2, 0, 1], [3, 2, 1, 0]]

其思想是编写一个函数，该函数接受一个列表列表，并将其递增。考虑一下简单的函数：

def permNums(inp, N=4):

newInp = []

for i in inp:

for j in range(N):

if j not in i: newInp.append( i+[j] )

return newInp

现在用空列表执行此功能。。。

In [22]: permNums([[]])

Out[22]: [[0], [1], [2], [3]]

当你用它的输出再次运行它时会发生什么？

In [23]: permNums(_)

Out[23]:

[[0, 1],

[0, 2],

[0, 3],

[1, 0],

[1, 2],

[1, 3],

[2, 0],

[2, 1],

[2, 3],

[3, 0],

[3, 1],

[3, 2]]

再重复一遍？

In [24]: permNums(_)

Out[24]:

[[0, 1, 2],

[0, 1, 3],

[0, 2, 1],

[0, 2, 3],

[0, 3, 1],

[0, 3, 2],

[1, 0, 2],

[1, 0, 3],

[1, 2, 0],

[1, 2, 3],

[1, 3, 0],

[1, 3, 2],

[2, 0, 1],

[2, 0, 3],

[2, 1, 0],

[2, 1, 3],

[2, 3, 0],

[2, 3, 1],

[3, 0, 1],

[3, 0, 2],

[3, 1, 0],

[3, 1, 2],

[3, 2, 0],

[3, 2, 1]]

再做一次，你就会得到你想要的结果。

现在您可以考虑简单的实现：

result = [[]]

for i in range(N): result = permNums(_)

这将解决您的问题(您只需要将索引映射到字符串，并加入结果)。然而，这不是经典的递归。对于递归，需要执行另外两个步骤。

调用函数本身

弄清楚什么时候这个自称的生意会停止。。。

调用函数本身很简单。只是替换

return newInp

具有

return permNums(newInp, N)

这一步并不奇怪，因为这正是您在iPython控制台上手动执行的操作。不过，你需要在某个时候停下来。在这种情况下，停止标准应该很简单。如果一个内部列表中的元素数== N，则停止。

因此，修改后的程序有两个简单的补充：

def permNums(inp, N=4):

if len(inp[0]) == N: return inp # stopping criterion

newInp = []

for i in inp:

for j in range(N):

if j not in i: newInp.append( i+[j] )

return permNums(newInp, N) # keep calling itself

print permNums([[]])

希望这有帮助。。。