使用itertools的python列表（仅移动2项，排列） 我从C++中作为我的第一编程长度，我刚刚进入Python和IM寻找一种方法来从列表中切换数字，C++中，这将是用指针用循环来移动它们，但是这次我需要在Python 中生成列表A到列表B的所有排列。

列表A（起始列表）和列表B（结果列表）

程序必须按顺序显示所有可能的组合，同时只移动2个数字，直到A列表变成B列表（以下示例简化为4个数字，可能不会显示所有组合）

为了实现这一点，我找到了一个模块，它包含很多函数，但是到目前为止还不能实现很多函数，下面的代码做了它需要的事情，但是它没有成对移动数字，也没有按顺序移动数字

import itertools

from itertools import product, permutations
A = ([1,2,3,4])  
B = ([4,2,3,1])  

print "\n"
print (list(permutations(sorted(B),4)))

---

我正在考虑添加一段时间（a！=B），然后停止排列，我已经尝试过了，但我不熟悉pythons语法，如果您能为我提供帮助，我将不胜感激。

我假设不需要对输入列表进行排序

from itertools import permutations
A = ([4, 3, 2, 1])
B = ([1,2,4, 3])

def print_combinations(start, target):
    # use list(permutations(sorted(start), len(start))) if sorting of start is really required
    all_perms = list(permutations(start, len(start)))
    if tuple(target) not in all_perms:
        # return empty list if target is not found in all permutations
        return []
    # return all combinations till target(inclusive)
    # using list slicing
    temp = all_perms[: all_perms.index(tuple(target)) + 1]
    return temp


print print_combinations(A, B)

---

我假设不需要对输入列表进行排序

from itertools import permutations
A = ([4, 3, 2, 1])
B = ([1,2,4, 3])

def print_combinations(start, target):
    # use list(permutations(sorted(start), len(start))) if sorting of start is really required
    all_perms = list(permutations(start, len(start)))
    if tuple(target) not in all_perms:
        # return empty list if target is not found in all permutations
        return []
    # return all combinations till target(inclusive)
    # using list slicing
    temp = all_perms[: all_perms.index(tuple(target)) + 1]
    return temp


print print_combinations(A, B)

---

你问什么还不完全清楚。我认为您要求的是一种pythonic方法来交换列表中的两个元素。在Python中，通常将数据结构分为不可变和可变。在这种情况下，您可以谈论元组或列表

假设您希望交换元素

i

和

j

，并使

j

更大

对于不可变元组，pythonic方法将通过如下切片生成新元组：

next = (current[:i] + current[j:j+1] + current[i+1:j]
                    + current[i:i+1] + current[j+1:])

对于可变列表，它将是python，与C++相同，尽管它在Python中更漂亮：

list[i],list[j] = list[j],list[i]

---

或者，您可以询问如何解决置换问题，在这种情况下，答案是itertools并没有提供太多帮助。我建议深度优先搜索。

你问的问题还不完全清楚。我认为您要求的是一种pythonic方法来交换列表中的两个元素。在Python中，通常将数据结构分为不可变和可变。在这种情况下，您可以谈论元组或列表

假设您希望交换元素

i

和

j

，并使

j

更大

对于不可变元组，pythonic方法将通过如下切片生成新元组：

next = (current[:i] + current[j:j+1] + current[i+1:j]
                    + current[i:i+1] + current[j+1:])

对于可变列表，它将是python，与C++相同，尽管它在Python中更漂亮：

list[i],list[j] = list[j],list[i]

---

或者，您可以询问如何解决置换问题，在这种情况下，答案是itertools并没有提供太多帮助。我建议进行深度优先搜索。

假设您正在询问解决此排列问题的最佳方法-以下是不同的答案：

把所有的排列看作一个集合<代码>itertools。排列以某种顺序生成所有这些排列。这正是你想要的，如果你想找到所有或一些排列。但那不是你想要的。您正试图通过这些排列找到路径

itertools.permutations

以顺序生成所有排列，但不一定是您想要的顺序。当然不是所有的订单：它只生成一次

因此，可以生成所有排列，并将它们视为网络的节点。然后，您可以在节点通过单个交换连接时链接节点，以获得图形。这就是所谓的永面体。然后，您可以在该图上进行搜索，以查找您感兴趣的从

a

到

b

的所有循环自由路径。这当然是可能的，但并不是真正的最优。提前构建整个图形是不必要的步骤，因为它可以根据需要轻松生成

下面是一些Python代码，它可以做到这一点：它通过在需要时为节点生成邻居，在permutohedron上生成深度优先搜索。但它不使用

itertools

a = (1,2,3,4)
b = (4,2,3,1)

def children(current):
    for i in range(len(a)-1):
        yield (current[:i] + (current[i+1],current[i]) +
                   current[i+2:])

def dfs(current,path,path_as_set):
    path.append(current)
    path_as_set.add(current)
    if current == b:
        yield path
    else:
        for next_perm in children(current):
            if next_perm in path_as_set:
                continue
            for path in dfs(next_perm,path,path_as_set):
                yield path
    path.pop()
    path_as_set.remove(current)

for path in dfs(a,[],set()):
    print(path)

如果您真的对使用

itertools.permutations

感兴趣，那么您试图研究的对象实际上是：

itertools.permutations(itertools.permutations(a))

---

这将生成通过排列集的所有可能路径。您可以处理此问题，拒绝任何不是从

a

开始并且包含非单个交换步骤的步骤。但这是一个非常糟糕的方法：这个列表非常长。

假设你问的是解决这个排列问题的最佳方法-这里有一个不同的答案：

把所有的排列看作一个集合<代码>itertools。排列以某种顺序生成所有这些排列。这正是你想要的，如果你想找到所有或一些排列。但那不是你想要的。您正试图通过这些排列找到路径

itertools.permutations

以顺序生成所有排列，但不一定是您想要的顺序。当然不是所有的订单：它只生成一次

因此，可以生成所有排列，并将它们视为网络的节点。然后，您可以在节点通过单个交换连接时链接节点，以获得图形。这就是所谓的永面体。然后您可以在该图上进行搜索，以找到您感兴趣的从

a

到

b

的所有无循环路径。这当然是可能的，但并不是真正的最优。提前构建整个图形是不必要的步骤，因为它可以根据需要轻松生成

下面是一些Python代码，它可以做到这一点：它通过在需要时为节点生成邻居，在permutohedron上生成深度优先搜索。信息技术