我需要替换一些字符，如下所示：&➔ \&，#➔ \#，...

我编码如下，但是我想应该有一些更好的方法。有什么提示吗？

strs = strs.replace('&', '\&')
strs = strs.replace('#', '\#')
...

替换两个字符

我给当前答案中的所有方法加上了一个额外的时间。

使用输入字符串abc&def#ghi并替换＆-> \＆和＃-> \＃，最快的方法是将替换链接在一起，如下所示：text.replace('&', '\&').replace('#', '\#')。

每个功能的时间：

• a）1000000次循环，每循环3：1.47μs最佳
• b）1000000次循环，每循环3：1.51μs最佳
• c）100000个循环，每个循环最好为3：12.3μs
• d）100000个循环，每个循环最好为3:12μs
• e）100000个循环，每个循环最好为3：3.27μs
• f）1000000次循环，最好为3：每个循环0.817μs
• g）100000个循环，每个循环3：3.64μs最佳
• h）1000000次循环，每循环最好3：0.927μs
• i）1000000次循环，最佳3：每个循环0.814μs

功能如下：

def a(text):
    chars = "&#"
    for c in chars:
        text = text.replace(c, "\\" + c)


def b(text):
    for ch in ['&','#']:
        if ch in text:
            text = text.replace(ch,"\\"+ch)


import re
def c(text):
    rx = re.compile('([&#])')
    text = rx.sub(r'\\\1', text)


RX = re.compile('([&#])')
def d(text):
    text = RX.sub(r'\\\1', text)


def mk_esc(esc_chars):
    return lambda s: ''.join(['\\' + c if c in esc_chars else c for c in s])
esc = mk_esc('&#')
def e(text):
    esc(text)


def f(text):
    text = text.replace('&', '\&').replace('#', '\#')


def g(text):
    replacements = {"&": "\&", "#": "\#"}
    text = "".join([replacements.get(c, c) for c in text])


def h(text):
    text = text.replace('&', r'\&')
    text = text.replace('#', r'\#')


def i(text):
    text = text.replace('&', r'\&').replace('#', r'\#')

像这样计时：

python -mtimeit -s"import time_functions" "time_functions.a('abc&def#ghi')"
python -mtimeit -s"import time_functions" "time_functions.b('abc&def#ghi')"
python -mtimeit -s"import time_functions" "time_functions.c('abc&def#ghi')"
python -mtimeit -s"import time_functions" "time_functions.d('abc&def#ghi')"
python -mtimeit -s"import time_functions" "time_functions.e('abc&def#ghi')"
python -mtimeit -s"import time_functions" "time_functions.f('abc&def#ghi')"
python -mtimeit -s"import time_functions" "time_functions.g('abc&def#ghi')"
python -mtimeit -s"import time_functions" "time_functions.h('abc&def#ghi')"
python -mtimeit -s"import time_functions" "time_functions.i('abc&def#ghi')"

替换17个字符

下面是类似的代码，可完成相同的操作，但转义的字符更多（\`* _ {}>＃+-。！$）：

def a(text):
    chars = "\\`*_{}[]()>#+-.!$"
    for c in chars:
        text = text.replace(c, "\\" + c)


def b(text):
    for ch in ['\\','`','*','_','{','}','[',']','(',')','>','#','+','-','.','!','$','\'']:
        if ch in text:
            text = text.replace(ch,"\\"+ch)


import re
def c(text):
    rx = re.compile('([&#])')
    text = rx.sub(r'\\\1', text)


RX = re.compile('([\\`*_{}[]()>#+-.!$])')
def d(text):
    text = RX.sub(r'\\\1', text)


def mk_esc(esc_chars):
    return lambda s: ''.join(['\\' + c if c in esc_chars else c for c in s])
esc = mk_esc('\\`*_{}[]()>#+-.!$')
def e(text):
    esc(text)


def f(text):
    text = text.replace('\\', '\\\\').replace('`', '\`').replace('*', '\*').replace('_', '\_').replace('{', '\{').replace('}', '\}').replace('[', '\[').replace(']', '\]').replace('(', '\(').replace(')', '\)').replace('>', '\>').replace('#', '\#').replace('+', '\+').replace('-', '\-').replace('.', '\.').replace('!', '\!').replace('$', '\$')


def g(text):
    replacements = {
        "\\": "\\\\",
        "`": "\`",
        "*": "\*",
        "_": "\_",
        "{": "\{",
        "}": "\}",
        "[": "\[",
        "]": "\]",
        "(": "\(",
        ")": "\)",
        ">": "\>",
        "#": "\#",
        "+": "\+",
        "-": "\-",
        ".": "\.",
        "!": "\!",
        "$": "\$",
    }
    text = "".join([replacements.get(c, c) for c in text])


def h(text):
    text = text.replace('\\', r'\\')
    text = text.replace('`', r'\`')
    text = text.replace('*', r'\*')
    text = text.replace('_', r'\_')
    text = text.replace('{', r'\{')
    text = text.replace('}', r'\}')
    text = text.replace('[', r'\[')
    text = text.replace(']', r'\]')
    text = text.replace('(', r'\(')
    text = text.replace(')', r'\)')
    text = text.replace('>', r'\>')
    text = text.replace('#', r'\#')
    text = text.replace('+', r'\+')
    text = text.replace('-', r'\-')
    text = text.replace('.', r'\.')
    text = text.replace('!', r'\!')
    text = text.replace('$', r'\$')


def i(text):
    text = text.replace('\\', r'\\').replace('`', r'\`').replace('*', r'\*').replace('_', r'\_').replace('{', r'\{').replace('}', r'\}').replace('[', r'\[').replace(']', r'\]').replace('(', r'\(').replace(')', r'\)').replace('>', r'\>').replace('#', r'\#').replace('+', r'\+').replace('-', r'\-').replace('.', r'\.').replace('!', r'\!').replace('$', r'\$')

这是相同输入字符串的结果abc&def#ghi：

• a）100000个循环，每个循环最好3：6.72μs
• b）100000个循环，每个循环最好3：2.64μs
• c）100000个循环，每个循环最好3：11.9μs
• d）100000个循环，每个循环的最佳时间为3：4.92μs
• e）100000个循环，每个循环最好为3：2.96μs
• f）100000个循环，每个循环最好为3：4.29μs
• g）100000个循环，每个循环最好为3：4.68μs
• h）100000次循环，每循环3：4.73μs最佳
• i）100000个循环，每个循环最好为3：4.24μs

并使用更长的输入字符串（## *Something* and [another] thing in a longer sentence with {more} things to replace$）：

• a）100000个循环，每个循环的最佳时间为3：7.59μs
• b）100000个循环，每个循环最好为3：6.54μs
• c）100000个循环，每个循环最好3：16.9μs
• d）100000个循环，每个循环最好3.:7.29μs
• e）100000个循环，每个循环最好为3：12.2μs
• f）100000个循环，每个循环最好为3：3.38μs
• g）10000个循环，每个循环最好3：21.7μs
• h）100000个循环，最佳3：每个循环5.7μs
• i）100000个循环，每个循环中最好为3：5.13μs

添加几个变体：

def ab(text):
    for ch in ['\\','`','*','_','{','}','[',']','(',')','>','#','+','-','.','!','$','\'']:
        text = text.replace(ch,"\\"+ch)


def ba(text):
    chars = "\\`*_{}[]()>#+-.!$"
    for c in chars:
        if c in text:
            text = text.replace(c, "\\" + c)

输入较短时：

• ab）100000个循环，每个循环中最好为3：7.05μs
• ba）100000个循环，最佳3：每个循环2.4μs

输入较长时：

• ab）100000个循环，每个循环最好为3：3.71μs
• ba）100000次循环，每循环最好3：6.08μs

因此，我将使用ba其可读性和速度。

附录

在注释中出现提示时，ab和之间的区别ba是if c in text:检查。让我们针对另外两个变体进行测试：

def ab_with_check(text):
    for ch in ['\\','`','*','_','{','}','[',']','(',')','>','#','+','-','.','!','$','\'']:
        if ch in text:
            text = text.replace(ch,"\\"+ch)

def ba_without_check(text):
    chars = "\\`*_{}[]()>#+-.!$"
    for c in chars:
        text = text.replace(c, "\\" + c)

在Python 2.7.14和3.6.3上以及与先前设置不同的计算机上，每个循环的时间以μs为单位。

╭────────────╥──────┬───────────────┬──────┬──────────────────╮
│ Py, input  ║  ab  │ ab_with_check │  ba  │ ba_without_check │
╞════════════╬══════╪═══════════════╪══════╪══════════════════╡
│ Py2, short ║ 8.81 │    4.22       │ 3.45 │    8.01          │
│ Py3, short ║ 5.54 │    1.34       │ 1.46 │    5.34          │
├────────────╫──────┼───────────────┼──────┼──────────────────┤
│ Py2, long  ║ 9.3  │    7.15       │ 6.85 │    8.55          │
│ Py3, long  ║ 7.43 │    4.38       │ 4.41 │    7.02          │
└────────────╨──────┴───────────────┴──────┴──────────────────┘

我们可以得出以下结论：

• 有支票的人的速度比没有支票的人快4倍

• ab_with_check在Python 3上稍有领先，但是ba（带检查）在Python 2上有更大的领先优势

• 但是，这里最大的教训是Python 3比Python 2快3倍！Python 3上最慢的速度与Python 2上最快的速度之间并没有太大的区别！

>>> string="abc&def#ghi"
>>> for ch in ['&','#']:
...   if ch in string:
...      string=string.replace(ch,"\\"+ch)
...
>>> print string
abc\&def\#ghi

replace像这样简单地链接功能

strs = "abc&def#ghi"
print strs.replace('&', '\&').replace('#', '\#')
# abc\&def\#ghi

如果替代品的数量会更多，您可以采用这种通用方式

strs, replacements = "abc&def#ghi", {"&": "\&", "#": "\#"}
print "".join([replacements.get(c, c) for c in strs])
# abc\&def\#ghi

这是使用str.translate和的python3方法str.maketrans：

s = "abc&def#ghi"
print(s.translate(str.maketrans({'&': '\&', '#': '\#'})))

打印的字符串是abc\&def\#ghi。

您是否总是要加一个反斜杠？如果是这样，请尝试

import re
rx = re.compile('([&#])')
#                  ^^ fill in the characters here.
strs = rx.sub('\\\\\\1', strs)

它可能不是最有效的方法，但我认为这是最简单的方法。

晚会晚了，但是我在这个问题上浪费了很多时间，直到找到答案。

简短而甜美，translate优于replace。如果您对随时间推移进行的功能优化更感兴趣，请不要使用replace。

还可以使用translate，如果你不知道，如果重叠设置的用于替换的字符将被替换的字符集。

例子：

使用replace您会天真地希望代码片段"1234".replace("1", "2").replace("2", "3").replace("3", "4")返回"2344"，但实际上它将返回"4444"。

翻译似乎可以执行OP最初想要的功能。

您可以考虑编写通用的转义函数：

def mk_esc(esc_chars):
    return lambda s: ''.join(['\\' + c if c in esc_chars else c for c in s])

>>> esc = mk_esc('&#')
>>> print esc('Learn & be #1')
Learn \& be \#1

这样，您就可以使用应转义的字符列表来配置函数。

仅供参考，这对OP几乎没有用处，甚至没有用，但是对其他读者可能有用（请不要投票，我知道这一点）。

作为一个有点荒谬但有趣的练习，我想看看我是否可以使用python函数式编程来替换多个字符。我很确定这不会打败两次调用replace（）。如果性能是一个问题，您可以轻松地在rust，C，julia，perl，java，javascript和awk中击败它。它使用一个名为pytoolz的外部“帮助程序”包，该包通过cython加速（cytoolz，这是一个pypi包）。

from cytoolz.functoolz import compose
from cytoolz.itertoolz import chain,sliding_window
from itertools import starmap,imap,ifilter
from operator import itemgetter,contains
text='&hello#hi&yo&'
char_index_iter=compose(partial(imap, itemgetter(0)), partial(ifilter, compose(partial(contains, '#&'), itemgetter(1))), enumerate)
print '\\'.join(imap(text.__getitem__, starmap(slice, sliding_window(2, chain((0,), char_index_iter(text), (len(text),))))))

我什至不解释这一点，因为没有人会费心使用它来完成多次替换。但是，我在执行此操作时感到有些成就，并认为这可能会激发其他读者或赢得代码混淆竞赛。

使用reduce可以在python2.7和python3。*中使用，您可以轻松地以干净的pythonic方式替换多个子字符串。

# Lets define a helper method to make it easy to use
def replacer(text, replacements):
    return reduce(
        lambda text, ptuple: text.replace(ptuple[0], ptuple[1]), 
        replacements, text
    )

if __name__ == '__main__':
    uncleaned_str = "abc&def#ghi"
    cleaned_str = replacer(uncleaned_str, [("&","\&"),("#","\#")])
    print(cleaned_str) # "abc\&def\#ghi"

在python2.7中，您不必导入reduce，但在python3。*中，您必须从functools模块中导入它。

也许是char替换的简单循环：

a = '&#'

to_replace = ['&', '#']

for char in to_replace:
    a = a.replace(char, "\\"+char)

print(a)

>>> \&\#

这个怎么样？

def replace_all(dict, str):
    for key in dict:
        str = str.replace(key, dict[key])
    return str

然后

print(replace_all({"&":"\&", "#":"\#"}, "&#"))

输出

\&\#

类似于答案

>>> a = '&#'
>>> print a.replace('&', r'\&')
\&#
>>> print a.replace('#', r'\#')
&\#
>>> 

您希望使用“原始”字符串（由替换字符串作为前缀的“ r”表示），因为原始字符串不会特别对待反斜杠。