Question

给定字符串（或具有偶数字对的任何长度字符串）： “12345678”

我如何交换相邻的“单词”？

我想要的结果是 “34127856”

除此之外，当我完成时，我需要交换多头。我想要的结果是： “78563412”

Answer 1

正则表达式方法：

import re
twopairs = re.compile(r'(..)(..)')
stringwithswappedwords = twopairs.sub(r'\2\1', basestring)
twoquads = re.compile(r'(....)(....)')
stringwithswappedlongs = twoquads.sub(r'\2\1', stringwithswappedwords)

修改：然而，这绝对不是Python中最快的方法 - 以下是人们如何发现这些事情：首先，将所有“竞争”方法写入模块，这里我称之为'swa.py' ......：< / p>

import re

twopairs = re.compile(r'(..)(..)')
twoquads = re.compile(r'(....)(....)')

def withre(basestring, twopairs=twopairs, twoquads=twoquads):
  stringwithswappedwords = twopairs.sub(r'\2\1', basestring)
  return twoquads.sub(r'\2\1', stringwithswappedwords)

def withoutre(basestring):
  asalist = list(basestring)
  asalist.reverse()
  for i in range(0, len(asalist), 2):
    asalist[i+1], asalist[i] = asalist[i], asalist[i+1]
  return ''.join(asalist)

s = '12345678'
print withre(s)
print withoutre(s)

请注意，我设置s并试用这两种方法进行快速健全性检查，他们实际上是在计算相同的结果 - 一般来说，这种“头对头表演比赛”的良好做法“！

然后，在shell提示符下，使用timeit，如下所示：

$ python -mtimeit -s'import swa' 'swa.withre(swa.s)' 78563412 78563412 10000 loops, best of 3: 42.2 usec per loop $ python -mtimeit -s'import swa' 'swa.withoutre(swa.s)' 78563412 78563412 100000 loops, best of 3: 9.84 usec per loop

...你发现在这种情况下，无RE方法的速度提高了大约4倍，值得进行优化。一旦你有了这样一个“测量线束”，当你在这个操作中需要“真正超快的速度”时，也可以很容易地尝试进一步优化的进一步优化和调整。

修改：例如，这是一种更快的方法（添加到相同的swa.py，当然最后一行为print faster(s); - ）：

def faster(basestring): asal = [basestring[i:i+2] for i in range(0, len(basestring), 2)] asal.reverse() return ''.join(asal)

这给出了：

$ python -mtimeit -s'import swa' 'swa.faster(swa.s)' 78563412 78563412 78563412 100000 loops, best of 3: 5.58 usec per loop

从最简单的无RE方法的约9.8下降约5.6微秒，是另一个可能值得的微优化。

等等，当然 - 有一个古老的民间（伪）定理说任何程序都可以制作至少一个字节，并且至少快一个纳秒......; - ）

编辑：并“证明”伪定理，这是一种完全不同的方法（替换swa.py的结尾）......：

import array def witharray(basestring): a2 = array.array('H', basestring) a2.reverse() return a2.tostring() s = '12345678' # print withre(s) # print withoutre(s) print faster(s) print witharray(s)

这给出了：

$ python -mtimeit -s'import swa' 'swa.witharray(swa.s)' 78563412 78563412 100000 loops, best of 3: 3.01 usec per loop

进一步可能获得加速。

Answer 2

import re
re.sub(r'(..)(..)', r'\2\1', '12345678')
re.sub(r'(....)(....)', r'\2\1', '34127856')

Answer 3

仅用于字符串“12345678”

from textwrap import wrap
s="12345678"
t=wrap(s,len(s)/2)
a,b=wrap(t[0],len(t[0])/2)
c,d=wrap(t[1],len(t[1])/2)
a,b=b,a
c,d=d,c
print a+b+c+d

你可以使它成为一个泛型函数来做变长字符串。

输出

$ ./python.py
34127856

Answer 4

>>> import re
>>> re.sub("(..)(..)","\\2\\1","12345678")
'34127856'
>>> re.sub("(....)(....)","\\2\\1","34127856")
'78563412'

Answer 5

如果您想进行字节序转换，请在原始二进制数据上使用Python的struct module。

如果这不是你的目标，这里有一个简单的示例代码来重新排列一个8个字符的字符串：

def wordpairswapper(s):
    return s[6:8] + s[4:6] + s[2:4] + s[0:2]

Answer 6

我使用以下方法：

data = "deadbeef"
if len(data) == 4: #2 bytes, 4 characters
   value = socket.ntohs(int(data, 16))
elif len(data) >= 8:
   value = socket.ntohl(int(data, 16))
else:
   value = int(data, 16)

适合我！

如何交换十六进制字节字符串中的相邻字节（带或不带正则表达式）

6 个答案: