1

我正在尝试在参考序列和测试序列之间进行所有可能的替换。序列将始终具有相同的长度，目标是将测试字符替换为参考字符。

Ref= "AAAAAAAAA"
Test="AAATAATTA"

期望的输出：

AAATAATTA, AAATAAAAA,  AAATAATAA,  AAATAATTA,  AAAAAATTA,  AAAAAATAA,  AAAAAAATA
4

3 回答 3

3

itertools.product如果zip将两个字符串放在一起（将它们变成一组 2 元组product以查找组合），则可以使用它。然后，您可能希望将它们统一在一个集合中。总而言之，它看起来像这样：

>>> {''.join(t) for t in product(*zip(Ref, Test))}
{'AAAAAAAAA', 'AAAAAATAA', 'AAAAAAATA', 'AAATAATTA', 'AAATAATAA', 'AAATAAAAA', 'AAATAAATA', 'AAAAAATTA'}

进一步分解一下，因为如果您不熟悉相关功能，它看起来有点像线路噪音......

这是zip将我们的两个字符串转换为对的迭代（将其包装在列表推导中以便于打印，但我们将在下一阶段将其删除）：

>>> [t for t in zip(Ref, Test)]
[('A', 'A'), ('A', 'A'), ('A', 'A'), ('A', 'T'), ('A', 'A'), ('A', 'A'), ('A', 'T'), ('A', 'T'), ('A', 'A')]

该product函数将任意数量的迭代作为参数；我们想使用以下方法将所有 2 元组作为单独的参数提供给它*：

>>> [t for t in product(*zip(Ref, Test))]
[('A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A'), ('A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A'), ... (a whole lot of tuples)

用于join将这些元组转回字符串：

>> [''.join(t) for t in product(*zip(Ref, Test))]
['AAAAAAAAA', 'AAAAAAAAA', 'AAAAAAATA', 'AAAAAAATA', ... (still a whole lot of strings)

通过将其设为集合推导 ( {}) 而不是列表推导 ( [])，我们得到的只是唯一元素。

于 2020-04-28T15:13:35.920 回答
0

itertools.combinations可用于生成位置组合，您可以在第二个参数处控制元组大小itertools.combinations

import itertools

REF = "AAAAAAAAA"
poses =(3,6,7)
for i in range(1, len(poses) + 1):
    tmp = itertools.combinations(poses, i)
    for j in tmp:
        result = REF
        print(j)
        for k in j:
            result = result[:k]+'T' + result[k+1:]
        print(result)

结果：

(3,)
AAATAAAAA
(6,)
AAAAAATAA
(7,)
AAAAAAATA
(3, 6)
AAATAATAA
(3, 7)
AAATAAATA
(6, 7)
AAAAAATTA
(3, 6, 7)
AAATAATTA
于 2020-04-28T15:20:13.947 回答
0

如果您想避免使用itertools（因为.product会在您的情况下制作更多相同字符串的副本），您可以使用recursion并generators实现自己的解决方案。我的倾向是，如果这些序列非常大，这应该会更有效率。但是，如果不是，那么itertools解决方案会更好。

def take_some(to: str, from_: str):
     assert len(to) == len(from_)  # your precondition
     if to == from_:  # no-more left to check ('' == '') in worst case
         yield from_
         return
     for i, (l, r) in enumerate(zip(to, from_)):
          if l != r:
               # do not take the character
               rest = take_some(to[i+1:], from_[i+1:])
               for res in rest:
                   yield to[:i+1] + res
                   yield to[:i] + r + res
               return

给予

In [2]: list(take_some("AAAAAAAAA", "AAATAATTA"))                                     
['AAAAAAAAA',
 'AAATAAAAA',
 'AAAAAATAA',
 'AAATAATAA',
 'AAAAAAATA',
 'AAATAAATA',
 'AAAAAATTA',
 'AAATAATTA']

请注意，这确实包含原始Ref字符串，如果您真的不想包含它，您可以在最后将其从结果中删除。

于 2020-04-28T15:17:37.610 回答