替换字符串中多个字符的最佳方法?

我需要替换一些字符如下:&➔\&， #➔\#，…

我的编码如下，但我想应该有更好的方法。有提示吗?

strs = strs.replace('&', '\&')
strs = strs.replace('#', '\#')
...
714692 次浏览
小开

你总是要在反斜杠前加引号吗?如果是，试试

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

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

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

你想要使用一个'raw'字符串(用'r'作为替换字符串的前缀)，因为raw字符串不会特别对待反斜杠。

小开

你可以考虑写一个通用的转义函数:

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

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

小开

简单地像这样链接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
小开
最佳答案

替换两个字符

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

输入字符串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:5.38 μs /循环
  • G) 10000个循环，3个最佳:每循环21.7 μs
  • h) 100000次循环，最佳3:5.7 μs /循环
  • 我)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 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中最快的没有太大区别!

小开

仅供参考，这对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),))))))

我甚至不打算解释这一点，因为没有人会使用它来完成多次替换。尽管如此，我还是觉得这样做有点成就感，并认为它可能会激励其他读者，或者赢得一场代码混淆竞赛。

小开

使用在python2.7和python3中可用的reduce。你可以用简洁的python方式替换多个子字符串。

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

小开

下面是一个python3方法，使用str.translate和str.maketrans:

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

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

小开

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

短小精悍的__ABC0优于replace。如果你对功能性随时间优化更感兴趣，不要使用replace。

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

举个例子:

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

翻译似乎执行了OP最初的期望。

小开

也许是一个简单的循环字符替换:

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({"&":"\&", "#":"\#"}, "&#"))

输出

\&\#

类似于回答

小开

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

import re
text = "hello ,world!"
replaces = {"hello": "hi", "world":" 2020", "!":"."}
regex = re.sub("|".join(replaces.keys()), lambda match: replaces[match.string[match.start():match.end()]], text)
print(regex)
小开

对于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']

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

Comparison

下面是用于上述比较的代码。我使用随机字符串来简化我的工作，要替换的字符是从字符串本身随机选择的。(注意:我在这里使用的是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)
小开

这将帮助人们找到一个简单的解决方案。

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

输出:

他是我的家人他的pli

小开

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

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

< >强: enter image description here < / p >

< >强后: enter image description here < / p >


提交答案