98

在 Python 中，我不知道何时何地使用字符串连接与字符串替换。由于字符串连接的性能有了很大的提升，这（变得越来越）是一种风格上的决定，而不是一个实际的决定吗？

举一个具体的例子，应该如何处理灵活 URI 的构造：

DOMAIN = 'http://stackoverflow.com'
QUESTIONS = '/questions'

def so_question_uri_sub(q_num):
    return "%s%s/%d" % (DOMAIN, QUESTIONS, q_num)

def so_question_uri_cat(q_num):
    return DOMAIN + QUESTIONS + '/' + str(q_num)

编辑：还有关于加入字符串列表和使用命名替换的建议。这些是中心主题的变体，即，哪种方式是什么时候做的正确方式？感谢您的回复！

4

9 回答 9

55

根据我的机器，连接（显着）更快。但在风格上，如果性能不重要，我愿意付出替代的代价。好吧，如果我需要格式化，甚至不需要问这个问题......除了使用插值/模板之外别无选择。

>>> import timeit
>>> def so_q_sub(n):
...  return "%s%s/%d" % (DOMAIN, QUESTIONS, n)
...
>>> so_q_sub(1000)
'http://stackoverflow.com/questions/1000'
>>> def so_q_cat(n):
...  return DOMAIN + QUESTIONS + '/' + str(n)
...
>>> so_q_cat(1000)
'http://stackoverflow.com/questions/1000'
>>> t1 = timeit.Timer('so_q_sub(1000)','from __main__ import so_q_sub')
>>> t2 = timeit.Timer('so_q_cat(1000)','from __main__ import so_q_cat')
>>> t1.timeit(number=10000000)
12.166618871951641
>>> t2.timeit(number=10000000)
5.7813972166853773
>>> t1.timeit(number=1)
1.103492206766532e-05
>>> t2.timeit(number=1)
8.5206360154188587e-06

>>> def so_q_tmp(n):
...  return "{d}{q}/{n}".format(d=DOMAIN,q=QUESTIONS,n=n)
...
>>> so_q_tmp(1000)
'http://stackoverflow.com/questions/1000'
>>> t3= timeit.Timer('so_q_tmp(1000)','from __main__ import so_q_tmp')
>>> t3.timeit(number=10000000)
14.564135316080637

>>> def so_q_join(n):
...  return ''.join([DOMAIN,QUESTIONS,'/',str(n)])
...
>>> so_q_join(1000)
'http://stackoverflow.com/questions/1000'
>>> t4= timeit.Timer('so_q_join(1000)','from __main__ import so_q_join')
>>> t4.timeit(number=10000000)
9.4431309007150048
于 2008-12-18T00:07:44.600 回答
24

不要忘记命名替换：

def so_question_uri_namedsub(q_num):
    return "%(domain)s%(questions)s/%(q_num)d" % locals()
于 2008-12-18T00:22:59.343 回答
12

小心在循环中连接字符串！ 字符串连接的成本与结果的长度成正比。循环将您直接带到 N 平方的土地。某些语言会优化与最近分配的字符串的连接，但指望编译器将您的二次算法优化为线性是有风险的。最好使用原语 ( join?)，它接受整个字符串列表，进行一次分配，然后一次性将它们连接起来。

于 2008-12-18T04:40:07.623 回答
11

“由于字符串连接的性能有了很大的提升......”

如果性能很重要，很高兴知道这一点。

然而，我见过的性能问题从来没有归结为字符串操作。我通常遇到 I/O、排序和 O( n 2 ) 操作成为瓶颈的麻烦。

在字符串操作成为性能限制器之前，我会坚持使用显而易见的东西。大多数情况下，当它是一行或更少时，它是替换，当它有意义时是连接，当它很大时是一个模板工具（如 Mako）。

于 2008-12-18T00:18:13.050 回答
10

您想要连接/插值的内容以及您想要如何格式化结果应该会推动您的决定。

  • 字符串插值允许您轻松添加格式。实际上，您的字符串插值版本与您的串联版本不同；q_num它实际上在参数之前添加了一个额外的正斜杠。要执行相同的操作，您必须return DOMAIN + QUESTIONS + "/" + str(q_num)在该示例中进行编写。

  • 插值使格式化数字更容易；"%d of %d (%2.2f%%)" % (current, total, total/current)串联形式的可读性要低得多。

  • 当您没有固定数量的要字符串化的项目时，连接很有用。

另外，要知道 Python 2.6 引入了一个新版本的字符串插值，称为字符串模板：

def so_question_uri_template(q_num):
    return "{domain}/{questions}/{num}".format(domain=DOMAIN,
                                               questions=QUESTIONS,
                                               num=q_num)

字符串模板最终将取代 %-interpolation，但我认为这在很长一段时间内不会发生。

于 2008-12-18T00:10:09.900 回答
8

出于好奇，我只是在测试不同字符串连接/替换方法的速度。关于这个主题的谷歌搜索把我带到了这里。我想我会发布我的测试结果，希望它可以帮助某人做出决定。

    import timeit
    def percent_():
            return "test %s, with number %s" % (1,2)

    def format_():
            return "test {}, with number {}".format(1,2)

    def format2_():
            return "test {1}, with number {0}".format(2,1)

    def concat_():
            return "test " + str(1) + ", with number " + str(2)

    def dotimers(func_list):
            # runs a single test for all functions in the list
            for func in func_list:
                    tmr = timeit.Timer(func)
                    res = tmr.timeit()
                    print "test " + func.func_name + ": " + str(res)

    def runtests(func_list, runs=5):
            # runs multiple tests for all functions in the list
            for i in range(runs):
                    print "----------- TEST #" + str(i + 1)
                    dotimers(func_list)

...运行后runtests((percent_, format_, format2_, concat_), runs=5)，我发现 % 方法在这些小字符串上的速度大约是其他方法的两倍。concat 方法总是最慢的（几乎没有）。在方法中切换位置时存在非常微小的差异format()，但切换位置总是比常规格式方法慢至少 0.01。

测试结果样本：

    test concat_()  : 0.62  (0.61 to 0.63)
    test format_()  : 0.56  (consistently 0.56)
    test format2_() : 0.58  (0.57 to 0.59)
    test percent_() : 0.34  (0.33 to 0.35)

我运行这些是因为我确实在我的脚本中使用了字符串连接，我想知道成本是多少。我以不同的顺序运行它们，以确保没有任何干扰，或者首先或最后获得更好的性能。附带说明一下，我在这些函数中加入了一些更长的字符串生成器，例如"%s" + ("a" * 1024)，常规 concat 的速度几乎是使用formatand%方法的 3 倍（1.1 对 2.8）。我想这取决于字符串以及您要实现的目标。如果性能真的很重要，那么尝试不同的东西并测试它们可能会更好。我倾向于选择可读性而不是速度，除非速度成为问题，但这只是我。所以不喜欢我的复制/粘贴，我必须在所有内容上放置 8 个空格以使其看起来正确。我一般用4。

于 2013-05-13T03:27:35.843 回答
4

请记住，如果您计划维护或调试您的代码，风格决策是实际的决策 :-) Knuth 有一句名言（可能引用 Hoare？）：“我们应该忘记小的效率，比如说大约 97% 的时间：过早的优化是万恶之源。”

只要你小心不要（比如说）将 O(n) 任务变成 O(n 2 ) 任务，我会选择你认为最容易理解的那个。

于 2008-12-18T01:04:35.500 回答
0

我尽可能使用替代。如果我在说for循环中建立一个字符串，我只使用连接。

于 2008-12-17T23:56:12.457 回答
-1

实际上正确的做法是，在这种情况下（构建路径）是使用os.path.join. 不是字符串连接或插值

于 2011-08-20T03:56:37.653 回答