切换字符串中的每一对字符

Question

例如，有字符串：

abcdefghijklmnopqrstuvwxyz

应该是这样的：

badcfehgjilknmporqtsvuxwzy

我该怎么做呢？

我想到了一些效率不高的东西，比如：

s = str(range(ord('a'), ord('z') + 1))
new_s = ''
for i in xrange(len(s)):
    if i != 0 and i % 2 == 0:
        new_s += '_' + s[i]
    else:
        new_s += s[i]
# Now it should result in a string such as 'ab_cd_ef_...wx_yz'
l = new_s.split('_')
for i in xrange(len(l)):
    l[i] = l[i][::-1]
result = str(l)

有没有更好的方法？某种更有效或更通用的方法，所以我也可以更轻松地用 3 个字母来处理它？

Answer 1

您可以使用zip() 函数将元组列表返回为[(b,a), (d,c), ...]，并将.join() 方法应用于元组和列表的元素。

a = "abcdefghijklmnopqrstuvwxyz"
# a[::2] = "acegikmoqsuwy"
# a[1::2] = "bdfhjlnprtvx"
print "".join("".join(i) for i in zip(a[1::2], a[::2]))
>>> badcfehgjilknmporqtsvuxwzy

编辑：如@Ashwini 和@TigerhawkT3 所建议，要处理奇数长度字符串的情况，您可以将代码更改为：

print "".join("".join(i) for i in zip(a2, a1)) + a[-1] if len(a)%2 else '' 

Answer 2

不使用任何导入的一种解决方案是将字符串转换为迭代器，并在迭代期间通过在迭代器上调用 next 来获取下一个字符：

>>> s = "abcdefghijklmnopqrstuvwxyz"
>>> it = iter(s)
>>> ''.join(next(it, '') + c for c in it )
'badcfehgjilknmporqtsvuxwzy'

时间安排：

>>> s = "abcdefghijklmnopqrstuvwxyz" * 10**5
>>> def func_next_no_cache(s):
    it = iter(s)
    return ''.join([next(it, '') + c for c in it])
...
>>> %timeit func_next_no_cache(s)
1 loops, best of 3: 291 ms per loop

但是对next 的调用实际上会减慢它的速度，因为要找到next，Python 必须从本地范围开始进入内置函数，让我们缓存它并再试一次：

>>> def func_next_cache(s, next=next):
    it = iter(s)
    return ''.join([next(it, '') + c for c in it])
...
>>> %timeit func_next_cache(s)
1 loops, best of 3: 241 ms per loop

但最快的解决方案是使用itertools.izip_longest：

>>> from itertools import izip_longest
>>> def func_izip_l(s):
    it = iter(s)
    return "".join([b+a for a, b in  izip_longest(it, it, fillvalue='')])
...
>>> %timeit func_izip_l(s)

1 loops, best of 3: 209 ms per loop

@Joran 的代码在与列表而不是生成器表达式一起使用时也非常接近这个，但它在内存中创建了两个额外的字符串：

>>> %timeit "".join([b+a for a, b in izip_longest(s[::2], s[1::2], fillvalue="")])
1 loops, best of 3: 212 ms per loop

---

注意如果速度是一个问题，我们应该始终将list 发送给str.join：https://stackoverflow.com/a/9061024/846892

Answer 3

我不确定首先使用正则表达式总是最好的做法，但它似乎适合这里。找到 2 个字符，以相反的顺序将它们替换，然后继续直到你用完字符串。

import re

>>> s = "abcdefghijklmnopqrstuvwxyz"
>>> re.sub(r'(.)(.)', "\g<2>\g<1>", s)
'badcfehgjilknmporqtsvuxwzy'

很容易推广到其他数量的字符：

>>> def swap3(txt):
...    return re.sub(r'(.)(.)(.)', '\g<3>\g<2>\g<1>', txt)
...
>>> swap3(s)
'cbafedihglkjonmrqputsxwvyz'

或

>>> def parameterizedSwap(txt, numChars):
...    pat = r"(.)" * numChars
...    replace = "".join(["\g<{0}>".format(numChars-i) for i in range(numChars)])
...    return re.sub(pat, replace, txt)
...
>>> parameterizedSwap(s, 5)
'edcbajihgfonmlktsrqpyxwvuz'

Answer 4

from itertools import izip_longest as myzip
"".join(b+a for a,b in myzip(a[::2],a[1::2],fillvalue=""))

这与其他答案非常相似，只是更明确地向代码读者解释了它正在做什么

Answer 5

from itertools import zip, chain

c1 = [c for i, c in enumerate(s) if i % 2 == 0]
c2 = [c for i, c in enumerate(s) if i % 2 == 1]
''.join(chain.from_iterable(zip(c2,c1)))

Answer 6

遍历字符对并将它们与izip() 连接起来相当简单，并且可以通过在末尾添加条件连接来处理奇数字符串长度的处理。

from itertools import izip

s = "abcdefghijklmnopqrstuvwxyz"
print ("".join(((pair[1]+pair[0]) for pair in izip(*[iter(s)]*2))) +
            (s[-1] if len(s) % 2 else ''))

正如@Ashwini 在评论中所建议的那样，使用izip_longest() 而不是izip() 可以更简洁地完成同样的事情。

from itertools import izip_longest

s = "abcdefghijklmnopqrstuvwxyz"
print "".join(((pair[1]+pair[0]) for pair in
                    izip_longest(*[iter(s)]*2, fillvalue='')))