如何将递归分支为仅返回列表列表

Question

我遇到了一个问题，我需要什么 returning 应该是一个列表列表，每个嵌套列表是一个包含 2 个字符串的列表。我找不到一种方法来有效地展平这个列表，或者 return 只是列表的列表，因为嵌套列表的数量是不确定的。这发生在我的递归函数中，我为每个递归循环分支到 3 个不同的递归路径。我目前拥有的是：

def f(used, sequences):
    if sequences[0] == '' or sequences[1] == '':
        if sequences[0] == '' and sequences[1] == '':
            return [used[0], used[1]]
        elif sequences[0] != '':
            return [used[0] + sequences[0], used[1] + '-' * len(sequences[0])]
        elif sequences[1] != '':
            return [used[0] + '-' * len(sequences[1]), used[1] + sequences[1]]
    else:
        return [f([sequences[0][-1] + used[0], sequences[1][-1] + used[1]], [sequences[0][:-1], sequences[1][:-1]]),
        f([sequences[0][-1] + used[0], '-' + used[1]], [sequences[0][:-1], sequences[1]]),
        f(['-' + used[0], sequences[1][-1] + used[1]], [sequences[0], sequences[1][:-1]])]

我想要的是比对是配对的 2 个序列的所有可能比对。但是，它会产生一系列复杂的嵌套循环，由于序列的长度可能不同，因此无法确定。使用上述函数会产生：

sequences = ['GAA', 'TGT']
alignments = f(['', ''], sequences)
print(alignments)
>>>[[[['GAA', 'TGT'], ['GAA-', '-GTT'], ['-AAG', 'TGT-']], [['GAA-', 'G-TT'], ['GAA--', '--TTG'], [['G-AA', 'TG-T'], ['G-AA-', '-G-TT'], ['--AAG', 'TG-T-']]], [['A-AG', 'TGT-'], [['GA-A', 'T-GT'], ['GA-A-', '--GTT'], ['-A-AG', 'T-GT-']], ['--AGA', 'TGT--']]], [[['GAA-', 'GT-T'], ['GAA--', '-T-TG'], [['G-AA', 'TGT-'], ['G-AA-', '-GT-T'], ['--AAG', 'TGT--']]], [['GAA--', 'T--TG'], ['GAA---', '---TGT'], [['G-AA-', 'GT--T'], ['G-AA--', '-T--TG'], [['G--AA', 'TGT--'], ['G--AA-', '-GT--T'], ['---AAG', 'TGT---']]]], [[['GA-A', 'TGT-'], ['GA-A-', '-GT-T'], ['-A-AG', 'TGT--']], [['GA-A-', 'G-T-T'], ['GA-A--', '--T-TG'], [['G-A-A', 'TG-T-'], ['G-A-A-', '-G-T-T'], ['--A-AG', 'TG-T--']]], [['A--AG', 'TGT--'], [['GA--A', 'T-GT-'], ['GA--A-', '--GT-T'], ['-A--AG', 'T-GT--']], ['---AGA', 'TGT---']]]], [[['AA-G', 'TGT-'], [['GAA-', 'T-GT'], ['GAA--', '--GTT'], ['-AA-G', 'T-GT-']], ['-A-GA', 'TGT--']], [[['GAA-', 'TG-T'], ['GAA--', '-G-TT'], ['-AA-G', 'TG-T-']], [['GAA--', 'G--TT'], ['GAA---', '---TTG'], [['G-AA-', 'TG--T'], ['G-AA--', '-G--TT'], ['--AA-G', 'TG--T-']]], [['A-A-G', 'TG-T-'], [['GA-A-', 'T-G-T'], ['GA-A--', '--G-TT'], ['-A-A-G', 'T-G-T-']], ['--A-GA', 'TG-T--']]], [['A--GA', 'TGT--'], [['AA--G', 'T-GT-'], [['GAA--', 'T--GT'], ['GAA---', '---GTT'], ['-AA--G', 'T--GT-']], ['-A--GA', 'T-GT--']], ['---GAA', 'TGT---']]]]

当我希望它以 [['str', 'str'], ['str', 'str'], ['str', 'str']... 形式出现时，它会生成类似 [[[['str', 'str'], ['str', 'str'], ['str', 'str']], [['str, 'str']... 的内容有没有办法修复我的递归以实现这种情况，或者我可以编写一个函数来按照我想要的方式展平它？

已尝试 Ch3steR 的推荐：

def flat(lst):
     if not isinstance(lst[0][0],list):
         return lst
     else:
        return flat(sum(lst,[]))

我离我想要的更近了。但是，其中仍然存在一些嵌套循环。

sequences = ['GAA', 'TGT']
alignments = f(['', ''], sequences)
alignments = flat(alignments)
print(alignments)

现在生产：

[['GAA', 'TGT'], ['GAA-', '-GTT'], ['-AAG', 'TGT-'], ['GAA-', 'G-TT'], ['GAA--', '--TTG'], [['G-AA', 'TG-T'], ['G-AA-', '-G-TT'], ['--AAG', 'TG-T-']], ['A-AG', 'TGT-'], [['GA-A', 'T-GT'], ['GA-A-', '--GTT'], ['-A-AG', 'T-GT-']], ['--AGA', 'TGT--'], ['GAA-', 'GT-T'], ['GAA--', '-T-TG'], [['G-AA', 'TGT-'], ['G-AA-', '-GT-T'], ['--AAG', 'TGT--']], ['GAA--', 'T--TG'], ['GAA---', '---TGT'], [['G-AA-', 'GT--T'], ['G-AA--', '-T--TG'], [['G--AA', 'TGT--'], ['G--AA-', '-GT--T'], ['---AAG', 'TGT---']]], [['GA-A', 'TGT-'], ['GA-A-', '-GT-T'], ['-A-AG', 'TGT--']], [['GA-A-', 'G-T-T'], ['GA-A--', '--T-TG'], [['G-A-A', 'TG-T-'], ['G-A-A-', '-G-T-T'], ['--A-AG', 'TG-T--']]], [['A--AG', 'TGT--'], [['GA--A', 'T-GT-'], ['GA--A-', '--GT-T'], ['-A--AG', 'T-GT--']], ['---AGA', 'TGT---']], ['AA-G', 'TGT-'], [['GAA-', 'T-GT'], ['GAA--', '--GTT'], ['-AA-G', 'T-GT-']], ['-A-GA', 'TGT--'], [['GAA-', 'TG-T'], ['GAA--', '-G-TT'], ['-AA-G', 'TG-T-']], [['GAA--', 'G--TT'], ['GAA---', '---TTG'], [['G-AA-', 'TG--T'], ['G-AA--', '-G--TT'], ['--AA-G', 'TG--T-']]], [['A-A-G', 'TG-T-'], [['GA-A-', 'T-G-T'], ['GA-A--', '--G-TT'], ['-A-A-G', 'T-G-T-']], ['--A-GA', 'TG-T--']], ['A--GA', 'TGT--'], [['AA--G', 'T-GT-'], [['GAA--', 'T--GT'], ['GAA---', '---GTT'], ['-AA--G', 'T--GT-']], ['-A--GA', 'T-GT--']], ['---GAA', 'TGT---']]

Answer 1

根据我的理解，我发布了这个答案。

您使用 sum 减少嵌套列表的 1dim。

def flat(lst):
     if not isinstance(lst[0][0],list):
         return lst
     else:
        return flat(sum(lst,[]))

a=[[[['str', 'str'], ['str', 'str'], ['str', 'str']], [['str', 'str']]]]
flat(a)
#[['str', 'str'], ['str', 'str'], ['str', 'str'], ['str', 'str']]

编辑：对于任意嵌套列表。

def flat(lst,curr=[]):
    if len(lst)==2 and all(isinstance(i,str) for i in lst):
        return [lst]
    else:
        for i in lst:
            curr=curr+flat(i)
    return curr

如何将递归分支为仅返回列表列表

How to branch recursion into returning only a list of lists

python

recursion

list

nested-lists

python-3.x