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

对于Python 3.8及以上版本，可以使用赋值表达式

[text := text.replace(s, f"\\{s}") for s in "&#" if s in text];

虽然，我不确定这是否被认为是PEP 572中描述的赋值表达式的“适当使用”，但看起来很干净，(在我看来)读起来很好。如果在REPL中运行，末尾的分号会抑制输出。

如果您也想要所有中间字符串，这将是“合适的”。例如，(去掉所有小写元音):

text = "Lorem ipsum dolor sit amet"
intermediates = [text := text.replace(i, "") for i in "aeiou" if i in text]

['Lorem ipsum dolor sit met',
 'Lorm ipsum dolor sit mt',
 'Lorm psum dolor st mt',
 'Lrm psum dlr st mt',
 'Lrm psm dlr st mt']

从好的方面来看，它似乎(出乎意料地?)比公认答案中的一些更快的方法要快，并且似乎在增加字符串长度和增加替换次数的情况下都表现得很好。

下面是用于上述比较的代码。我使用随机字符串来简化我的工作，要替换的字符是从字符串本身随机选择的。(注意:我在这里使用的是ipython的%timeit magic，所以在ipython/jupyter中运行它)。

import random, string

def make_txt(length):
    "makes a random string of a given length"
    return "".join(random.choices(string.printable, k=length))

def get_substring(s, num):
    "gets a substring"
    return "".join(random.choices(s, k=num))

def a(text, replace): # one of the better performing approaches from the accepted answer
    for i in replace:
        if i in text:
             text = text.replace(i, "")

def b(text, replace):
    _ = (text := text.replace(i, "") for i in replace if i in text) 


def compare(strlen, replace_length):
    "use ipython / jupyter for the %timeit functionality"

    times_a, times_b = [], []

    for i in range(*strlen):
        el = make_txt(i)
        et = get_substring(el, replace_length)

        res_a = %timeit -n 1000 -o a(el, et) # ipython magic

        el = make_txt(i)
        et = get_substring(el, replace_length)
        
        res_b = %timeit -n 1000 -o b(el, et) # ipython magic

        times_a.append(res_a.average * 1e6)
        times_b.append(res_b.average * 1e6)
        
    return times_a, times_b

#----run
t2 = compare((2*2, 1000, 50), 2)
t10 = compare((2*10, 1000, 50), 10)

下面给出了or条件的例子，它将删除给定字符串中的所有'和'。传递任意数量的字符，以|分隔

import re
test = re.sub("('|,)","",str(jsonAtrList))

之前:

后:

替换两个字符

我计算了当前答案中的所有方法以及一个额外的方法。

使用abc&def#ghi输入字符串并替换& -> \&和# -> \#，最快的方法是像这样将替换链接在一起:text。取代 ('&', '\&').取代 ('#', '\#').

每个函数的计时:

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*和[另一个]thing在一个较长的句子中，用{more}东西替换$):

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:5.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:7.71 μs /回路 Ba) 100000个循环，最佳3:6.08 μs /循环

我用ba表示可读性和速度。

齿顶高

根据评论中的黑客提示，ab和ba之间的一个区别是文本中的if c: check。让我们用另外两种变体来测试它们:

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(带check)在Python 2上有更大的领先 然而，这里最大的教训是Python 3比Python 2快3倍!Python 3中最慢的和Python 2中最快的没有太大区别!

下面是使用str.translate和str.maketrans的python3方法:

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)

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