当值是不同长度的列表时使用字典更新列表

Question

*** 更新 **** 额外的字母“A”是个问题。我在这里重新表述一下。也许更清楚？ 我必须使用具有可变长度列表作为其值的字典来替换列表中的值。例如：

variants = {C:["cat", "can", "car"], D:["do","die"], Z:["zen", "zoo"]}

还有一个清单：

Letters = ["C", "D", "Z"]

我想要这样的列表输出

PotentialWords = [["cat", "do", "zen"], ["can", "die", "zoo"],["car", "do", "zen"], ["car", "die", "zoo"]

所有元素在每一步都得到更新，但如果 索引超过，则 更新被保留，我们得到所有变体相互交叉。

到目前为止我所拥有的是：

max_len = max([len(words) for words in variants.values()])

for i in range(max_len):
    var = []
    for let in Letters:
        if let not in variants.keys():
           var.append(let)
        else:
            if i < len(variants[let]):
              var.append(variants[let][i])
            elif i > len(variants[let]):
              var.append(let)

这给出了错误的输出：

OutputWords = [["cat", "do", "zen"], ["can", "die", "zoo"], ["car"]]

您的所有帮助将不胜感激 :) * 更新* 感谢评论者，此问题已更新以更清晰。以前的输入是

Letters = ["C", "D", "Z", "A"]

然后输出

[["cat", "do", "zen", "A"], ["can", "die", "zoo","A"],["car", "A"]]

** 请只看上面的输入/输出

Answer 1

0   1   2   3
a0  a1  a2
b0  b1  b2  b3
c0  c1

假设您有这些列表，并且字母是 [a, b, c]，我认为您要做的是将所有内容填充到与最长相同的长度，然后压缩所有内容。

所以它会变成这样，然后你可以阅读列

0   1   2   3
a0  a1  a2  a0
b0  b1  b2  b3
c0  c1  c0  c1

如果这是你想做的，这能解决吗？

max_len = max([len(words) for words in variants.values()])
results = []
for i in range(max_len):
    var = []
    for let in Letters:
        index = i % len(Letters[let])
        var.append(Letters[let][index])
    results.append(var)

Answer 2

函数式编程的力量开始发挥作用。我使用了itertools：cycle、islice 和zip 的众所周知的功能：

from itertools import cycle, islice
variants = {"C":["cat", "can", "car"], "D":["do","die"], "Z":["zen", "zoo"]}
letters = ["C", "D", "Z"]

def take_first_n_items(iterable, n):
    return list(islice(iterable, max_len)) 

max_len = max([len(words) for words in variants.values()])
phrase_iterables = [cycle(variants[letter]) for letter in letters]
full_values_of_variants = [take_first_n_items(iterable, max_len) for iterable in phrase_iterables]
results = list(zip(*full_values_of_variants))
print(results)

它是如何工作的：

#phrase_iterables = [('cat', 'can', 'car','cat',...), ('do', 'die', 'do', ...) , ('zen', 'zoo', 'zen', 'zoo',...)]
#full_values_of_variants = [['cat', 'can', 'car'], ['do', 'die', 'do'], ['zen', 'zoo', 'zen']]

输出：[('cat', 'do', 'zen'), ('can', 'die', 'zoo'), ('car', 'do', 'zen')]

注意：list(islice(iterable, max_len)) 使用了不必要的额外迭代。您可以将其替换为 islice(iterable, max_len)。

Answer 3

我会通过图表来解决这个问题。想象每个列表在图中处于某个深度级别。

     root
   /  |  \
 cat can  car
  |\  /|\ /|
 do   die
  |\  /|
 zen zoo

在这里，我们假设根元素“root”和列表Letters 是每个列表在图中出现的顺序。所以C : [cat, can, car] 将位于深度 1，D: [do, die] 将位于级别 2..等等。

我们可以使用以下函数轻松创建这个无向图：

variants = {"C":["cat", "can", "car"], "D":["do","die"], "Z":["zen", "zoo"]}

Letters = ["C", "D", "Z"]

def create_graph(list_dict, depth_order):
  graph = {"root": set(list_dict[depth_order[0]])}
  for i in range(1, len(depth_order)):
    parents = list_dict[depth_order[i-1]]
    children = list_dict[depth_order[i]]
    # Connect parent to children
    for elem in parents:
      graph[elem] = set(children)
    # Connect children tp parent
    for elem in children:
      graph[elem] = set(parents)
  return graph

graph = create_graph(variants, Letters)
print(graph)

请注意，每个级别如果完全连接到下一个级别。因此，如果我们找到从第 1 层中的一个元素到最后一层中的另一个元素的路径，我们会找到组合的所有变体。我们可以简单地使用深度优先搜索 (link)

def dfs_paths(graph, start, goal):
  stack = [(start, [start])]
  while stack:
    (vertex, path) = stack.pop()
    for next in graph[vertex] - set(path):
      if next == goal:
        yield path + [next]
      else:
        stack.append((next, path + [next]))

现在我们可以使用所需的开始和结束节点调用此函数：

print(list(dfs_paths(graph, 'cat', 'zen')))

这会产生：

[['cat', 'die', 'zen'], ['cat', 'die', 'zoo', 'do', 'zen'], ['cat', 'do', 'zen'], ['cat', 'do', 'zoo', 'die', 'zen']]

我们可以过滤此列表以仅包含长度 = len(Letters) 的元素，这将消除 DFS 跟踪上一级的间接路径。

输出：

[['cat', 'die', 'zen'], ['cat', 'do', 'zen']]

让我知道它是否适合您。干杯！