为什么在Pythonreplace比translate快1.5倍？
In [188]: s = '1 a 2'
In [189]: s.replace(' ','')
Out[189]: '1a2'
In [190]: s.translate(None,' ')
Out[190]: '1a2'
In [191]: %timeit s.replace(' ','')
1000000 loops, best of 3: 399 ns per loop
In [192]: %timeit s.translate(None,' ')
1000000 loops, best of 3: 614 ns per loop
假设Python 2.7（因为我必须在没有说明的情况下翻转硬币），我们可以在string.py:中找到字符串的源代码。translate和字符串替换
>>> import inspect
>>> import string
>>> inspect.getsourcefile(string.translate)
'/usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/lib/python2.7/string.py'
>>> inspect.getsourcefile(string.replace)
'/usr/local/Cellar/python/2.7.9/Frameworks/Python.framework/Versions/2.7/lib/python2.7/string.py'
>>>
哦，我们不能，as string.py以开头
"""A collection of string operations (most are no longer used).
Warning: most of the code you see here isn't normally used nowadays.
Beginning with Python 1.6, many of these functions are implemented as
methods on the standard string object.
我给你投了赞成票，因为你开始走剖析的道路，所以让我们继续往下看：
from cProfile import run
from string import ascii_letters
s = '1 a 2'
def _replace():
for x in range(5000000):
s.replace(' ', '')
def _translate():
for x in range(5000000):
s.translate(None, ' ')
更换：
run("_replace()")
5000004 function calls in 2.059 seconds
Ordered by: standard name
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.976 0.976 2.059 2.059 <ipython-input-3-9253b3223cde>:8(_replace)
1 0.000 0.000 2.059 2.059 <string>:1(<module>)
1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}
5000000 1.033 0.000 1.033 0.000 {method 'replace' of 'str' objects}
1 0.050 0.050 0.050 0.050 {range}
用于翻译：
run("_translate()")
5000004 function calls in 1.785 seconds
Ordered by: standard name
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.977 0.977 1.785 1.785 <ipython-input-3-9253b3223cde>:12(_translate)
1 0.000 0.000 1.785 1.785 <string>:1(<module>)
1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}
5000000 0.756 0.000 0.756 0.000 {method 'translate' of 'str' objects}
1 0.052 0.052 0.052 0.052 {range}
我们的函数调用数量是相同的，并不是说更多的函数调用意味着运行会更慢，但这通常是一个很好的地方。有趣的是translate在我的机器上运行得比replace快！考虑一下不单独测试变化的乐趣——这并不重要，因为我们只关心能够说出为什么会有。
在任何情况下，我们至少现在知道可能存在性能差异，并且在评估字符串对象的方法时确实存在这种差异（请参见tottime）。translate __docstring__表明有一个转换表在起作用，而replace只提到旧到新的子字符串替换。
让我们向我们的老伙伴dis寻求提示：
from dis import dis
替换：
def dis_replace():
'1 a 2'.replace(' ', '')
dis(dis_replace)
dis("'1 a 2'.replace(' ', '')")
3 0 LOAD_CONST 1 ('1 a 2')
3 LOAD_ATTR 0 (replace)
6 LOAD_CONST 2 (' ')
9 LOAD_CONST 3 ('')
12 CALL_FUNCTION 2
15 POP_TOP
16 LOAD_CONST 0 (None)
19 RETURN_VALUE
和translate，它对我来说运行得更快：
def dis_translate():
'1 a 2'.translate(None, ' ')
dis(dis_translate)
2 0 LOAD_CONST 1 ('1 a 2')
3 LOAD_ATTR 0 (translate)
6 LOAD_CONST 0 (None)
9 LOAD_CONST 2 (' ')
12 CALL_FUNCTION 2
15 POP_TOP
16 LOAD_CONST 0 (None)
19 RETURN_VALUE
不幸的是，这两个看起来与dis相同，这意味着我们应该从这里开始查找字符串的C源代码（通过查看我现在使用的python版本的python源代码找到）](https://hg.python.org/cpython/file/a887ce8611d2/Objects/stringobject.c)。
这是翻译的来源
如果您浏览注释，可以看到根据输入的长度，有多个replace函数定义行。
我们的子字符串替换选项有：
replace_substring_in_place
/* len(self)>=1, len(from)==len(to)>=2, maxcount>=1 */
Py_LOCAL(PyStringObject *)
replace_substring_in_place(PyStringObject *self,
和replace_substring:
/* len(self)>=1, len(from)>=2, len(to)>=2, maxcount>=1 */
Py_LOCAL(PyStringObject *)
replace_substring(PyStringObject *self,
和replace_delete_single_character:
/* Special case for deleting a single character */
/* len(self)>=1, len(from)==1, to="", maxcount>=1 */
Py_LOCAL(PyStringObject *)
replace_delete_single_character(PyStringObject *self,
char from_c, Py_ssize_t maxcount)
'1 a 2'.replace(' ', '')是一个len（self）==6，用一个空字符串替换1个字符，使其成为replace_delete_single_character。
你可以自己查看函数体，但答案是"对于这个特定的输入，C函数体在replace_delete_single_character中运行得比string_translate更快
谢谢你提出这个问题。
随着N和M的增加，翻译可能会更快，其中N是唯一字符替换映射的数量，M是正在翻译的字符串的长度。
import random
import string
import timeit
import re
def do_translation(N,M):
trans_map = random.sample(string.ascii_lowercase,N),random.sample(string.ascii_lowercase,N)
trans_tab = string.maketrans(*map("".join,trans_map))
s = "".join(random.choice(string.ascii_lowercase) for _ in range(M))
return s.translate(trans_tab)
def do_resub(N,M):
trans_map = random.sample(string.ascii_lowercase,N),random.sample(string.ascii_lowercase,N)
trans_tab = dict(zip(*trans_map))
s = "".join(random.choice(string.ascii_lowercase) for _ in range(M))
return re.sub("([%s])"%("".join(trans_map[0]),),lambda m:trans_tab.get(m.group(0),m.group(0)),s)
def do_replace(N,M):
trans_map = random.sample(string.ascii_lowercase,N),random.sample(string.ascii_lowercase,N)
s = "".join(random.choice(string.ascii_lowercase) for _ in range(M))
for k,v in zip(*trans_map):
s = s.replace(k,v)
return s
data = {}
for i in range(2,20,2):
for j in range(10,200,10):
data[(i,j)] = {
"translate":timeit.timeit("do_translation(%s,%s)"%(i,j),"from __main__ import do_translation,string,random",number=100),
"re.sub":timeit.timeit("do_resub(%s,%s)"%(i,j),"from __main__ import do_resub,re,random",number=100),
"replace":timeit.timeit("do_replace(%s,%s)"%(i,j),"from __main__ import do_replace,random",number=100)}
print data
将显示几个不同的时间。。。在其中一些情况下，包括翻译可能会更快（我考虑在这里添加一些图……但我已经在这个问题上投入了比我真正应该投入的更多的时间：P）