一部の文字を次のように置き換える必要があります：&➔ \&、#➔ \#、...

私は次のようにコーディングしましたが、もっと良い方法があるはずだと思います。ヒントはありますか？

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

2つの文字を置き換える

私は現在の回答のすべての方法と1つの追加の時間を計った。

入力文字列 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）100,000ループ、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）100,000ループ、最高3：ループあたり16.9μs
• d）100000ループ、3のベスト：7.29μs/ループ
• e）100,000ループ、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読みやすさとスピードのために使うつもりです。

補遺

コメント欄でhaccksに促され、間に1つの違いabとは、baあるif c in text:チェック。さらに2つのバリアントに対してテストしてみましょう。

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_checkPython 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.translateand を使用した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（）を2回呼び出すだけでは勝るとは思いません。そして、パフォーマンスが問題である場合、rust、C、julia、perl、java、javascript、そしておそらくawkでもこれを簡単に克服できます。cythonを介して高速化されたpytoolzと呼ばれる外部「ヘルパー」パッケージを使用します（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),))))))

これについて説明するつもりはありません。複数の置換を行うためにこれを使用する人は誰もいないからです。それにもかかわらず、私はこれを行うことである程度達成したと感じ、それが他の読者を刺激したり、コード難読化コンテストに勝ったりするかもしれないと思いました。

python2.7とpython3。*で利用可能なreduceを使用すると、クリーンで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モジュールからインポートする必要があります。

文字を置き換える単純なループかもしれません：

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」が付いている）を使用します。