是否有Python函数可以在两个等长字符串之间进行所有可能的替换？

我试图在引用和测试序列之间进行所有可能的替换。序列的长度始终相同，目标是用Ref的字符替换测试字符

Ref= "AAAAAAAAA"
Test="AAATAATTA"

期望输出：

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

如果将两个字符串压缩在一起，并将它们转换为一组2元组，则可以使用itertools.product进行此操作，以供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')]

乘积函数以任意数量的iterables作为参数；我们希望使用*，将所有2元组作为单独的参数提供给它：

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

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

通过将其设置为集合理解{}而不是列表理解[]，我们只会得到唯一的元素。

如果将两个字符串压缩在一起，将它们转换为一组2元组，以便product查找它们的组合，则可以使用itertools.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')]

乘积函数以任意数量的iterables作为参数；我们希望使用*，将所有2元组作为单独的参数提供给它：

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

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

---

通过将其设置为集合理解{}而不是列表理解[]，我们只会得到唯一的元素。

如果您不想使用as.product，那么您可以使用递归并实现自己的解决方案。我的倾向是，如果这些序列非常大，出于这个原因，这应该更有效。但是，如果不是这样，那么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字符串，如果您真的不想包含它，您可以在最后将其从结果中删除。

如果您想避免使用as。在您的情况下，产品将生成更多相等字符串的副本，您可以使用递归并实现自己的解决方案。我的倾向是，如果这些序列非常大，出于这个原因，这应该更有效。但是，如果不是这样，那么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字符串，如果您真的不想包含它，可以在结尾将其从结果中删除。

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

结果:

(3,)
AAATAAAAA
(6,)
AAAAAATAA
(7,)
AAAAAAATA
(3, 6)
AAATAATAA
(3, 7)
AAATAAATA
(6, 7)
AAAAAATTA
(3, 6, 7)
AAATAATTA

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

结果:

(3,)
AAATAAAAA
(6,)
AAAAAATAA
(7,)
AAAAAAATA
(3, 6)
AAATAATAA
(3, 7)
AAATAAATA
(6, 7)
AAAAAATTA
(3, 6, 7)
AAATAATTA

---

这是否意味着对于字符串长度中的每个i，新_字符串中的第i个字符可以是Ref[i]或Tests[i]？因此创建2^len-1个可能的新字符串，其中len=lenRef？但是，仅当Ref[i]~=Test[i]时才需要这些替换？这是否意味着对于字符串长度中的每个i，新_字符串中的第i个字符可以是Ref[i]或Tests[i]？因此创建2^len-1个可能的新字符串，其中len=lenRef？但是，您只希望在Ref[i]~=Test[i]时使用这些替换？