替换两个字符

Question

我需要更换一些字符，如下所示：& - ＆gt; \&，# - ＆gt; \#，...

我编码如下，但我想应该有更好的方法。任何提示？

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

Answer 1

替换两个字符

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

输入字符串abc&def#ghi并替换＆amp; - ＆GT; \＆安培;和＃ - ＆gt; ＃，最快的方法是将替换组合在一起，例如：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个字符

这里有类似的代码，但要使用更多的字符来逃避（\`* _ {}＆gt;＃+ - 。！$）：

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次：每次循环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提示，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上的最快之间没有太大的区别！

Answer 2

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

Answer 3

只需链接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

Answer 4

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

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

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

Answer 5

以下是使用str.translate和str.maketrans：

的python3方法

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

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

Answer 6

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

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

通过这种方式，您可以使用应转义的字符列表配置您的功能。

Answer 7

仅供参考，这对OP很少或没有用，但它可能对其他读者有用（请不要贬低，我知道这一点）。

作为一个有点荒谬但有趣的练习，想看看我是否可以使用python函数式编程来代替多个字符。我很确定这不会只是两次调用replace（）。如果性能是一个问题，你可以很容易地在Rust，C，julia，perl，java，javascript甚至awk中击败它。它使用名为pytoolz的外部“助手”包，通过cython（cytoolz, it's a pypi package）加速。

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),))))))

我甚至不打算解释这个，因为没有人会费心去做这个来完成多次替换。尽管如此，我觉得这样做有点成就，并认为它可能激发其他读者或赢得代码混淆比赛。

Answer 8

使用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模块中导入它。

Answer 9

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

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

如果您不知道要替换的字符集是否与用于替换的字符集重叠，也可以使用translate。

关键点：

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

翻译似乎可以执行OP最初想要的操作。

Answer 10

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

{$_.ManagerEmail -like $manager}

Answer 11

怎么样？

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

然后

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

输出

\&\#

类似于answer

Answer 12

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

你想使用'raw'字符串（用替换字符串前面的'r'表示），因为原始字符串不能特别处理反斜杠。

Answer 13

使用正则表达式的高级方式

const int HP

Answer 14

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

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

尽管，我不确定PEP 572中是否将其视为赋值表达式的“适当使用”，但看上去很干净（在我看来）。如果您还需要所有中间字符串，则这将是“适当的”。例如，（删除所有小写的元音）：

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魔术，所以请在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)

Answer 15

这将有助于寻找简单解决方案的人。

def replacemany(our_str, to_be_replaced:tuple, replace_with:str):
    for nextchar in to_be_replaced:
        our_str = our_str.replace(nextchar, replace_with)
    return our_str

os = 'the rain in spain falls mainly on the plain ttttttttt sssssssssss nnnnnnnnnn'
tbr = ('a','t','s','n')
rw = ''

print(replacemany(os,tbr,rw))

输出：

<块引用>

he ri i pi fll mily o he pli

使用Python替换多个字符

15 个答案:

替换两个字符

替换17个字符

附录