str.replace(..).replace(..) 是 Python 中的标准习惯用法吗？

Question

例如，假设我想要一个函数来转义字符串以便在 HTML 中使用（如 Django 的 转义过滤器）：

    def escape(string):
        """
        Returns the given string with ampersands, quotes and angle 
        brackets encoded.
        """
        return string.replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;').replace("'", '&#39;').replace('"', '&quot;')

这可行，但它很快就会变得丑陋，并且算法性能似乎很差（在本例中，字符串被重复遍历 5 次）。更好的是这样的：

    def escape(string):
        """
        Returns the given string with ampersands, quotes and angle 
        brackets encoded.
        """
        # Note that ampersands must be escaped first; the rest can be escaped in 
        # any order.
        return replace_multi(string.replace('&', '&'),
                             {'<': '&lt;', '>': '&gt;', 
                              "'": '&#39;', '"': '&quot;'})

这样的函数是否存在，或者是使用我之前编写的标准 Python 习惯用法？

Answer 1

您是否有一个运行速度太慢的应用程序，并且您对其进行分析后发现像这样的代码片段之类的行导致其速度缓慢？瓶颈出现在意想不到的地方。

当前代码片段遍历字符串 5 次，每次执行一件事。您建议遍历一次，可能每次都做五件事（或者至少每次都做一些事情）。目前还不清楚这是否会自动让我的工作做得更好。目前使用的算法是O(n*m)（假设字符串的长度比规则中的内容长），其中n是字符串的长度，m是替换规则的数量。我认为，你可以将算法复杂度降低到 O(n*log(m)) 之类的程度，并且在我们所处的特定情况下，原始事物都只有一个字符（但在多次调用的情况下则不然）一般情况下替换）—O(n)，但这并不重要，因为m是5，但n是无界的。

如果 m 保持不变，那么两个解决方案的复杂度实际上都是 O(n)。我不清楚尝试将五个简单的传球变成一个复杂的传球是否是一项有价值的任务，目前我无法猜测其实际时间。如果有什么东西可以让它更好地扩展，我会认为这是更有价值的任务。

在一次传递而不是连续传递中完成所有操作还需要回答有关如何处理冲突规则以及如何应用这些规则的问题。通过一系列replace 可以清楚地解决这些问题。

Answer 2

不如我们测试一下各种方法，看看哪种方法效果更快（假设我们只关心最快的方法）。

def escape1(input):
        return input.replace('&', '&').replace('<', '<').replace('>', '>').replace("'", ''').replace('"', '"')

translation_table = {
    '&': '&',
    '<': '<',
    '>': '>',
    "'": ''',
    '"': '"',
}

def escape2(input):
        return ''.join(translation_table.get(char, char) for char in input)

import re
_escape3_re = re.compile(r'[&<>\'"]')
def _escape3_repl(x):
    s = x.group(0)
    return translation_table.get(s, s)
def escape3(x):
    return _escape3_re.sub(_escape3_repl, x)

def escape4(x):
    return unicode(x).translate(translation_table)

test_strings = (
    'Nothing in there.',
    '<this is="not" a="tag" />',
    'Something & Something else',
    'This one is pretty long. ' * 50
)

import time

for test_i, test_string in enumerate(test_strings):
    print repr(test_string)
    for func in escape1, escape2, escape3, escape4:
        start_time = time.time()
        for i in xrange(1000):
            x = func(test_string)
        print '\t%s done in %.3fms' % (func.__name__, (time.time() - start_time))
    print

运行这个命令会给你带来：

'Nothing in there.'
    escape1 done in 0.002ms
    escape2 done in 0.009ms
    escape3 done in 0.001ms
    escape4 done in 0.005ms

'<this is="not" a="tag" />'
    escape1 done in 0.002ms
    escape2 done in 0.012ms
    escape3 done in 0.009ms
    escape4 done in 0.007ms

'Something & Something else'
    escape1 done in 0.002ms
    escape2 done in 0.012ms
    escape3 done in 0.003ms
    escape4 done in 0.007ms

'This one is pretty long. <snip>'
    escape1 done in 0.008ms
    escape2 done in 0.386ms
    escape3 done in 0.011ms
    escape4 done in 0.310ms

看起来只是一个接一个地替换它们是最快的。

编辑：再次运行测试 1000000 次迭代，给出前三个字符串的以下结果（第四个字符串在我的机器上需要太长时间等待 =P）：

'Nothing in there.'
    escape1 done in 0.001ms
    escape2 done in 0.008ms
    escape3 done in 0.002ms
    escape4 done in 0.005ms

'<this is="not" a="tag" />'
    escape1 done in 0.002ms
    escape2 done in 0.011ms
    escape3 done in 0.009ms
    escape4 done in 0.007ms

'Something & Something else'
    escape1 done in 0.002ms
    escape2 done in 0.011ms
    escape3 done in 0.003ms
    escape4 done in 0.007ms

数字几乎相同。在第一种情况下，它们实际上更加一致，因为直接字符串替换现在是最快的。

Answer 3

我更喜欢干净的东西，比如：

substitutions = [
    ('<', '<'),
    ('>', '>'),
    ...]

for search, replacement in substitutions:
    string = string.replace(search, replacement)

Answer 4

您可以使用减少：

reduce(lambda s,r: s.replace(*r),
       [('&', '&'),
        ('<', '<'),
        ('>', '>'),
        ("'", '''),
        ('"', '"')],
       string)

Answer 5

这就是Django 会：

def escape(html):
    """Returns the given HTML with ampersands, quotes and carets encoded."""
    return mark_safe(force_unicode(html).replace('&', '&').replace('<', '<').replace('>', '>').replace('"', '"').replace("'", '''))

Answer 6

根据bebraw的建议，这就是我最终使用的内容（当然，在一个单独的模块中）：

import re

class Subs(object):
    """
    A container holding strings to be searched for and replaced in
    replace_multi().

    Holds little relation to the sandwich.
    """
    def __init__(self, needles_and_replacements):
        """
        Returns a new instance of the Subs class, given a dictionary holding 
        the keys to be searched for and the values to be used as replacements.
        """
        self.lookup = needles_and_replacements
        self.regex = re.compile('|'.join(map(re.escape,
                                             needles_and_replacements)))

def replace_multi(string, subs):
    """
    Replaces given items in string efficiently in a single-pass.

    "string" should be the string to be searched.
    "subs" can be either:
        A.) a dictionary containing as its keys the items to be
            searched for and as its values the items to be replaced.
        or B.) a pre-compiled instance of the Subs class from this module
               (which may have slightly better performance if this is
                called often).
    """
    if not isinstance(subs, Subs): # Assume dictionary if not our class.
        subs = Subs(subs)
    lookup = subs.lookup
    return subs.regex.sub(lambda match: lookup[match.group(0)], string)

示例用法：

def escape(string):
    """
    Returns the given string with ampersands, quotes and angle 
    brackets encoded.
    """
    # Note that ampersands must be escaped first; the rest can be escaped in 
    # any order.
    escape.subs = Subs({'<': '<', '>': '>', "'": ''', '"': '"'})
    return replace_multi(string.replace('&', '&'), escape.subs)

好多了:)。感谢您的帮助。

编辑

没关系，迈克·格雷厄姆是对的。我对它进行了基准测试，结果发现替换实际上要慢得多。

代码：

from urllib2 import urlopen
import timeit

def escape1(string):
    """
    Returns the given string with ampersands, quotes and angle
    brackets encoded.
    """
    return string.replace('&', '&').replace('<', '<').replace('>', '>').replace("'", ''').replace('"', '"')

def escape2(string):
    """
    Returns the given string with ampersands, quotes and angle
    brackets encoded.
    """
    # Note that ampersands must be escaped first; the rest can be escaped in
    # any order.
    escape2.subs = Subs({'<': '<', '>': '>', "'": ''', '"': '"'})
    return replace_multi(string.replace('&', '&'), escape2.subs)

# An example test on the stackoverflow homepage.
request = urlopen('http://stackoverflow.com')
test_string = request.read()
request.close()

test1 = timeit.Timer('escape1(test_string)',
                     setup='from __main__ import escape1, test_string')
test2 = timeit.Timer('escape2(test_string)',
                     setup='from __main__ import escape2, test_string')
print 'multi-pass:', test1.timeit(2000)
print 'single-pass:', test2.timeit(2000)

输出：

multi-pass: 15.9897229671
single-pass: 66.5422530174

就这么多。

Answer 7

显然，通过正则表达式实现这一点很常见。您可以在 ASPN 和 此处。

Answer 8

好吧，我坐下来算了算。请不要生我的气，我的回答专门讨论了 ΤΖΩΤΖIΟΥ 的解决方案，但这有点难以硬塞在评论中，所以让我这样做。事实上，我还将提出一些与OP问题相关的考虑。

首先，我一直在与 ΤΖΩΤΖIΟΥ 讨论他的方法的优雅性、正确性和可行性。事实证明，它看起来像该提案，虽然它确实使用（本质上无序的）字典作为存储替换对的寄存器，但实际上确实始终返回正确的结果，而我声称它不会。这是因为下面第 11 行中对 itertools.starmap() 的调用将单个字符/字节对（稍后详细介绍）上的迭代器作为其第二个参数，该迭代器看起来像 [（'h'，'h'，），（'e'，'e'，），（'l'，'l'，），...]。这些字符/字节对是重复调用第一个参数 replacer.get 的内容。不可能遇到这样的情况：首先将 '>' 转换为 '>'，然后无意中再次转换为 '& amp;gt;'，因为每个字符/字节仅被考虑一次进行替换。所以这部分原则上是好的并且算法上是正确的。

下一个问题是可行性，其中包括对性能的考察。如果使用笨拙的代码在 0.01 秒内正确完成一项重要任务，而使用出色的代码则在 1 秒内正确完成，那么在实践中，尴尬可能会被认为是更好的选择（但前提是 1 秒的损失实际上是无法容忍的）。这是我用于测试的代码；它包括许多不同的实现。它是用 python 3.1 编写的，因此我们可以使用 unicode 希腊字母作为标识符，这本身就很棒（py3k 中的 zip 返回与 py2 中的 itertools.izip 相同）

import itertools                                                                  #01
                                                                                  #02
_replacements = {                                                                 #03
  '&': '&',                                                                   #04
  '<': '<',                                                                    #05
  '>': '>',                                                                    #06
  '"': '"',                                                                  #07
  "'": ''', }                                                                 #08
                                                                                  #09
def escape_ΤΖΩΤΖΙΟΥ( a_string ):                                                  #10
  return ''.join(                                                                 #11
    itertools.starmap(                                                            #12
      _replacements.get,                                                          #13
      zip( a_string, a_string ) ) )                                               #14
                                                                                  #15
def escape_SIMPLE( text ):                                                        #16
  return ''.join( _replacements.get( chr, chr ) for chr in text )                 #17
                                                                                  #18
def escape_SIMPLE_optimized( text ):                                              #19
  get = _replacements.get                                                         #20
  return ''.join( get( chr, chr ) for chr in text )                               #21
                                                                                  #22
def escape_TRADITIONAL( text ):                                                   #23
  return text.replace('&', '&').replace('<', '<').replace('>', '>')\    #24
    .replace("'", ''').replace('"', '"')                                 #25

：是计时结果：

escaping with SIMPLE            took 5.74664253sec for 100000 items
escaping with SIMPLE_optimized  took 5.11457801sec for 100000 items
escaping TRADITIONAL in-situ    took 0.57543013sec for 100000 items
escaping with TRADITIONAL       took 0.62347413sec for 100000 items
escaping a la ΤΖΩΤΖΙΟΥ          took 2.66592320sec for 100000 items

事实证明，原始发布者担心“传统”方法“很快就会变得丑陋并且算法性能似乎很差”，当放入这种背景下时，这似乎是部分没有根据的。它实际上表现最好；当隐藏到函数调用中时，我们确实会看到 8% 的性能损失（“调用方法的成本很高”，但一般来说您仍然应该这样做）。相比之下，ΤΖΩΤΖIΟY 的实现时间大约是传统方法的 5 倍，考虑到它的复杂性更高，必须与 Python 长期磨练的优化字符串方法竞争，这并不奇怪。

这里还有另一种算法，即简单算法。据我所知，这与 ΤΖΩΤΖIOY 的方法的作用非常相似：它迭代文本中的字符/字节并对每个字符/字节执行查找，然后将所有字符/字节连接在一起并返回生成的转义文本。您可以看到，如果一种方法涉及相当冗长且神秘的公式，那么简单的实现实际上是一目了然的。

然而，真正让我困惑的是 SIMPLE 方法的性能有多糟糕：它比传统方法慢大约 10 倍，也比 ΤΖΩΤΖlOY 方法慢两倍。我在这里完全不知所措，也许有人可以想出为什么会这样。它只使用Python最基本的构建块，并使用两个隐式迭代，因此它避免构建废弃列表和所有内容，但它仍然很慢，我不知道为什么。

让我通过对 ΤΖΩΤΖIΟΥ 解决方案的优点的评论来结束本次代码审查。我已经说得很清楚了，我发现代码很难阅读，而且对于手头的任务来说过于夸张。然而，更重要的是，我发现他对待字符的方式并确保对于给定的小范围字符，它们将以类似于字节的方式表现，这有点令人恼火。确保它适用于手头的任务，但是一旦我迭代例如字节串“ΤΖΩΤΖιΟΥ”，我所做的就是迭代表示单个字符的相邻字节。在大多数情况下，这正是您应该避免的；这正是为什么在 py3k 中“字符串”现在是旧的“unicode 对象”，而旧的“字符串”变成了“字节”和“字节数组”的原因。如果我要提名 py3k 的一个功能，可以保证将代码从 2 系列迁移到 3 系列，这可能会很昂贵，那么这就是 py3k 的这个单一属性。从那时起，我所有的编码问题中 98% 就迎刃而解了，而且没有什么聪明的技巧可以让我严重怀疑我的举动。所说的算法不是“概念上 8 位干净且 unicode 安全”，这对我来说是一个严重的缺点，因为现在是 2010 年。

Answer 9

如果您使用非 Unicode 字符串并且 Python < 3.0，尝试另一种 translate 方法：

# Python < 3.0
import itertools

def escape(a_string):
    replacer= dict( (chr(c),chr(c)) for c in xrange(256))
    replacer.update(
        {'&': '&',
         '<': '<',
         '>': '>',
         '"': '"',
         "'": '''}
    )
    return ''.join(itertools.imap(replacer.__getitem__, a_string))

if __name__ == "__main__":
    print escape('''"Hello"<i> to George's friend&co.''')

$ python so2484156.py 
"Hello"<i> to George's friend&co.

这更接近于输入字符串的“单次扫描”，根据您的意愿。

编辑

我的目的是创建一个不限于单字符替换的 unicode.translate 等效项，所以我想出了上面的答案；我收到了用户“flow”的评论，该评论几乎完全脱离了上下文，只有一个正确的点：上面的代码原样是用于处理字节字符串而不是unicode字符串。有一个明显的更新（即 unichr() … xrange(sys.maxunicode+1)），我非常不喜欢，所以我想出了另一个既适用于 unicode 又适用于字节字符串的函数，前提是 Python 保证：

all( (chr(i)==unichr(i) and hash(chr(i))==hash(unichr(i)))
    for i in xrange(128)) is True

新函数如下：

def escape(a_string):
    replacer= {
        '&': '&',
        '<': '<',
        '>': '>',
        '"': '"',
        "'": ''',
    }
    return ''.join(
        itertools.starmap(
            replacer.get, # .setdefault *might* be faster
            itertools.izip(a_string, a_string)
        )
    )

注意星图与元组序列的使用：对于不在替换字典中的任何字符，返回所述字符。