如何在字符串中每 2 个字符后插入一个字符

问题描述：

是否有一种 Python 方式可以将一个元素插入到字符串中的每个第二个元素中？

我有一个字符串：“aabbccdd”，我希望最终结果是“aa-bb-cc-dd”。

我不确定我该如何去做这件事。

解决方案 1：

>>> s = 'aabbccdd'
>>> '-'.join(s[i:i+2] for i in range(0, len(s), 2))
'aa-bb-cc-dd'

解决方案 2：

假设字符串的长度始终为偶数，

>>> s = '12345678'
>>> t = iter(s)
>>> '-'.join(a+b for a,b in zip(t, t))
'12-34-56-78'

也t可以用

>>> '-'.join(a+b for a,b in zip(s[::2], s[1::2]))
'12-34-56-78'

该算法是将字符串分组，然后将它们与-字符连接起来。

代码是这样写的，首先拆分成奇数和偶数。

>>> s[::2], s[1::2]
('1357', '2468')

然后使用该zip函数将它们组合成可迭代的元组。

>>> list( zip(s[::2], s[1::2]) )
[('1', '2'), ('3', '4'), ('5', '6'), ('7', '8')]

但元组不是我们想要的。这应该是字符串列表。这是列表推导的目的

>>> [a+b for a,b in zip(s[::2], s[1::2])]
['12', '34', '56', '78']

最后我们用它str.join()来合并列表。

>>> '-'.join(a+b for a,b in zip(s[::2], s[1::2]))
'12-34-56-78'

第一段代码是相同的想法，但如果字符串很长则消耗的内存较少。

解决方案 3：

我倾向于使用正则表达式，因为它看起来更简洁，而且通常比所有替代方案都快。除了必须面对有关正则表达式的传统观点外，我不确定它有什么缺点。

>>> s = 'aabbccdd'
>>> '-'.join(re.findall('..', s))
'aa-bb-cc-dd'

但此版本对于实际配对的要求很严格：

>>> t = s + 'e'
>>> '-'.join(re.findall('..', t)) 
'aa-bb-cc-dd'

...通过一些调整，你可以容忍奇数长度的字符串：

>>> '-'.join(re.findall('..?', t))
'aa-bb-cc-dd-e'

通常你会多次这样做，因此也许可以提前创建一个快捷方式：

PAIRS = re.compile('..').findall

out = '-'.join(PAIRS(in))

或者我在实际代码中会使用的内容：

def rejoined(src, sep='-', _split=re.compile('..').findall):
    return sep.join(_split(src))

>>> rejoined('aabbccdd', sep=':')
'aa:bb:cc:dd'

我时不时地使用类似这样的方法从 6 字节二进制输入创建 MAC 地址表示：

>>> addr = b'xdcxf7x09x11xa0x49'
>>> rejoined(addr[::-1].hex(), sep=':')
'49:a0:11:09:f7:dc'

解决方案 4：

如果您想在字符串长度为奇数时保留最后一个字符，那么您可以修改 KennyTM 的答案以使用itertools.izip_longest：

>>> s = "aabbccd"
>>> from itertools import izip_longest
>>> '-'.join(a+b for a,b in izip_longest(s[::2], s[1::2], fillvalue=""))
'aa-bb-cc-d'

或者

>>> t = iter(s)
>>> '-'.join(a+b  for a,b in izip_longest(t, t, fillvalue=""))
'aa-bb-cc-d'

解决方案 5：

这是一种列表理解方式，其条件值取决于枚举模数，最后一个奇数字符将单独分组：

for s  in ['aabbccdd','aabbccdde']:
    print(''.join([ char if not ind or ind % 2 else '-' + char
                    for ind,char in enumerate(s)
                    ]
                  )
          )
""" Output:
aa-bb-cc-dd
aa-bb-cc-dd-e
"""

解决方案 6：

这行代码可以达到这个目的。如果字符串中有奇数个字符，它将删除最后一个字符。

"-".join([''.join(item) for item in zip(mystring1[::2],mystring1[1::2])])

解决方案 7：

我在@SilentGhost 的答案中添加了测试

def insert_between_every_n_characters(original: str, inserted: str, step: int) -> str:
    """
    Insert a string between every N characters.

    >>> insert_between_every_n_characters('aabbccdd', '--', 1)
    'a--a--b--b--c--c--d--d'

    >>> insert_between_every_n_characters('aabbccdd', '-', 2)
    'aa-bb-cc-dd'

    >>> insert_between_every_n_characters('aabbccd', ':', 3)
    'aab:bcc:d'

    >>> insert_between_every_n_characters('aabbccdda', ':', 3)
    'aab:bcc:dda'

    >>> insert_between_every_n_characters('a', '-', 2)
    'a'

    >>> insert_between_every_n_characters('', '-', 2)
    ''
    """
    if step <= 0:
        raise ValueError(f"step must be greater than zero. Got: {step}")
    return inserted.join(original[i : i + step] for i in range(0, len(original), step))

解决方案 8：

当前的 Python 仅能使用生成器。

该解决方案的优点：

• “长度”只需指定一次，无需更新公式即可更改。

• 不使用索引（我称其为非 Python 风格）

from itertools import batched

s = 'aabbccdd'
r = '-'.join(''.join(b) for b in batched(s, 2))

Batched 从字符串中返回 2 个字符。它们与一个空字符“连接”。每个结果字符串都与之前的字符串用“-”连接，直到字符串用完。

解决方案 9：

正如PEP8 所述：

a += b对于形式为或 的语句，不要依赖 CPython 就地字符串连接的有效实现a = a + b。这种优化即使在 CPython 中也很脆弱（它只适用于某些类型），并且在实现中根本不存在。

一个 Pythonic 的方式来避免这种连接，并允许你连接字符串之外的可迭代对象，可以是：

':'.join(f'{s[i:i+2]}' for i in range(0, len(s), 2))

另一种更实用的方法可能是：

':'.join(map('{}{}'.format, *(s[::2], s[1::2]))) 

第二种方法有一个特殊功能（或缺陷），即只连接字母对。因此：

>>> s = 'abcdefghij'
'ab:cd:ef:gh:ij'

和：

>>> s = 'abcdefghi'
'ab:cd:ef:gh'