blocks|key|1451973|text|我尽可能地使用替换。我只有在构建字符串的时候才会使用连接，比如在for循环中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1451974|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I use substitution wherever I can. I only use concatenation if I'm building a string up in say a for-loop.

blocks|key|1452024|text|根据我的机器，连接速度(显着)更快。但在风格上，如果性能不重要，我愿意为替换付出代价。好吧，如果我需要格式化，甚至不需要问这个问题...除了使用插值/模板之外别无选择。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1452025|>>>+import+timeit
>>>+def+so_q_sub(n):
...++return+"%25s%25s/%25d"+%25+(DOMAIN,+QUESTIONS,+n)
...
>>>+so_q_sub(1000)
'http://stackoverflow.com/questions/1000'
>>>+def+so_q_cat(n):
...++return+DOMAIN+%2B+QUESTIONS+%2B+'/'+%2B+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|code-block|syntax|javascript|1452026|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Concatenation is (significantly) faster according to my machine. But stylistically, I'm willing to pay the price of substitution if performance is not critical. Well, and if I need formatting, there's no need to even ask the question... there's no option but to use interpolation/templating.

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

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

&gt;&gt;&gt; def so_q_join(n):
... return ''.join([DOMAIN,QUESTIONS,'/',str(n)])
...
&gt;&gt;&gt; so_q_join(1000)
'http://stackoverflow.com/questions/1000'
&gt;&gt;&gt; t4= timeit.Timer('so_q_join(1000)','from __main__ import so_q_join')
&gt;&gt;&gt; t4.timeit(number=10000000)
9.4431309007150048
</code></pre>

blocks|key|1452060|text|不要忘记命名替换：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1452061|def+so_question_uri_namedsub(q_num):
++++return+"%25(domain)s%25(questions)s/%25(q_num)d"+%25+locals()|code-block|syntax|javascript|1452062|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Don't forget about named substitution:

<pre><code>def so_question_uri_namedsub(q_num):
 return "%(domain)s%(questions)s/%(q_num)d" % locals()
</code></pre>

blocks|key|1667111|text|在这种情况下(构建路径)，实际上正确的做法是使用os.path.join。非字符串连接或插值|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1667112|entityMap^0|O|C|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Actually the correct thing to do, in this case (building paths) is to use <code>os.path.join</code>. Not string concatenation or interpolation

blocks|key|1667181|text|出于好奇，我只是在测试不同字符串连接/替换方法的速度。在谷歌上搜索这个主题后，我就来到了这里。我想我会发布我的测试结果，希望它能帮助别人做出决定。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1667182|++++import+timeit
++++def+percent_():
++++++++++++return+"test+%25s,+with+number+%25s"+%25+(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+"+%2B+str(1)+%2B+",+with+number+"+%2B+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+"+%2B+func.func_name+%2B+":+"+%2B+str(res)

++++def+runtests(func_list,+runs=5):
++++++++++++#+runs+multiple+tests+for+all+functions+in+the+list
++++++++++++for+i+in+range(runs):
++++++++++++++++++++print+"-----------+TEST+#"+%2B+str(i+%2B+1)
++++++++++++++++++++dotimers(func_list)|code-block|syntax|javascript|1667183|在运行runtests((percent_,+format_,+format2_,+concat_),+runs=5)时，我发现在这些小字符串上，%25方法的速度大约是其他方法的两倍。concat方法总是最慢的(勉强)。在format()方法中切换位置时有非常微小的差异，但切换位置总是比常规格式方法慢至少.01。|offset|length|style|CODE|1667184|测试结果样本：|1667185|++++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)|1667186|我之所以运行这些脚本，是因为我在脚本中使用了字符串连接，我想知道成本是多少。我以不同的顺序运行它们，以确保没有任何干扰，或者在第一或最后获得更好的性能。顺便说一句，我在这些函数中加入了一些更长的字符串生成器，如"%25s"+%2B+("a"+*+1024)和regular+concat，其速度几乎是使用format和%25方法的3倍(1.1vs2.8)。我猜这取决于字符串，以及您试图实现的目标。如果性能真的很重要，尝试不同的东西并测试它们可能会更好。我倾向于选择可读性而不是速度，除非速度成为一个问题，但这只是我的问题。所以我不喜欢我的复制/粘贴，我不得不在所有东西上放8个空格来使它看起来正确。我通常用4。|1667187|entityMap^0|0|0|3|1K|31|8|0|0|0|2X|J|44|6|4B|1|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]|$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|13|8|@$I|14|J|15|K|L]|$I|16|J|17|K|L]|$I|18|J|19|K|L]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|T|$]]

I was just testing the speed of different string concatenation/substitution methods out of curiosity. A google search on the subject brought me here. I thought I would post my test results in the hope that it might help someone decide.

<pre><code> 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)
</code></pre>

...After running <code>runtests((percent_, format_, format2_, concat_), runs=5)</code>, I found that the % method was about twice as fast as the others on these small strings. The concat method was always the slowest (barely). There were very tiny differences when switching the positions in the <code>format()</code> method, but switching positions was always at least .01 slower than the regular format method.

Sample of test results:

<pre><code> 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)
</code></pre>

I ran these because I do use string concatenation in my scripts, and I was wondering what the cost was. I ran them in different orders to make sure nothing was interfering, or getting better performance being first or last. On a side note, I threw in some longer string generators into those functions like <code>"%s" + ("a" * 1024)</code> and regular concat was almost 3 times as fast (1.1 vs 2.8) as using the <code>format</code> and <code>%</code> methods. I guess it depends on the strings, and what you are trying to achieve. If performance really matters, it might be better to try different things and test them. I tend to choose readability over speed, unless speed becomes a problem, but thats just me. SO didn't like my copy/paste, i had to put 8 spaces on everything to make it look right. I usually use 4.

In Python, the where and when of using string concatenation versus string substitution eludes me. As the string concatenation has seen large boosts in performance, is this (becoming more) a stylistic decision rather than a practical one?

For a concrete example, how should one handle construction of flexible URIs:

<pre><code>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)
</code></pre>

Edit: There have also been suggestions about joining a list of strings and for using named substitution. These are variants on the central theme, which is, which way is the Right Way to do it at which time? Thanks for the responses!

String concatenation vs. string substitution in Python

Python

在Python中，使用字符串连接和字符串替换的地点和时间让我摸不着头脑。由于字符串连接在性能上有了很大的提升，这(变得更多)是一个风格上的决定，而不是一个实际的决定？作为一个具体的例子，我们应该如何处理灵活URI的构造：DOMAIN = 'http://stackoverflow.com'QUESTIONS = '/q...

问Python中的字符串连接与字符串替换
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python中的字符串连接与字符串替换EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python中的字符串连接与字符串替换
EN