Python相当于Java StringBuffer吗?


74

Python中有像Java一样的东西StringBuffer吗?由于字符串在Python中也是不可变的,因此在循环中对其进行编辑将效率很低。


4
通过构建字符串列表并join()在循环后对其进行使用,您可能会获得类似的效果。但是我敢肯定,还有一种更Python化的方式(可能涉及列表理解)。
Joachim Sauer

Answers:


90

Python中的高效字符串连接是一篇比较老的文章,它的主要说法是朴素的连接比连接慢得多,这不再有效,因为从那时起这部分已在CPython中进行了优化:

CPython实现细节:如果s和t都是字符串,则某些Python实现(例如CPython)通常可以对s = s + t或s + = t形式的赋值执行就地优化。如果适用,此优化将使二次运行的可能性大大降低。此优化取决于版本和实现。对于性能敏感的代码,最好使用str.join()方法,以确保各个版本和实现之间一致的线性串联性能。@ http://docs.python.org/2/library/stdtypes.html

我对他们的代码做了一些调整,并在我的机器上得到了以下结果:

from cStringIO import StringIO
from UserString import MutableString
from array import array

import sys, timeit

def method1():
    out_str = ''
    for num in xrange(loop_count):
        out_str += `num`
    return out_str

def method2():
    out_str = MutableString()
    for num in xrange(loop_count):
        out_str += `num`
    return out_str

def method3():
    char_array = array('c')
    for num in xrange(loop_count):
        char_array.fromstring(`num`)
    return char_array.tostring()

def method4():
    str_list = []
    for num in xrange(loop_count):
        str_list.append(`num`)
    out_str = ''.join(str_list)
    return out_str

def method5():
    file_str = StringIO()
    for num in xrange(loop_count):
        file_str.write(`num`)
    out_str = file_str.getvalue()
    return out_str

def method6():
    out_str = ''.join([`num` for num in xrange(loop_count)])
    return out_str

def method7():
    out_str = ''.join(`num` for num in xrange(loop_count))
    return out_str


loop_count = 80000

print sys.version

print 'method1=', timeit.timeit(method1, number=10)
print 'method2=', timeit.timeit(method2, number=10)
print 'method3=', timeit.timeit(method3, number=10)
print 'method4=', timeit.timeit(method4, number=10)
print 'method5=', timeit.timeit(method5, number=10)
print 'method6=', timeit.timeit(method6, number=10)
print 'method7=', timeit.timeit(method7, number=10)

结果:

2.7.1 (r271:86832, Jul 31 2011, 19:30:53) 
[GCC 4.2.1 (Based on Apple Inc. build 5658) (LLVM build 2335.15.00)]
method1= 0.171155929565
method2= 16.7158739567
method3= 0.420584917068
method4= 0.231794118881
method5= 0.323612928391
method6= 0.120429992676
method7= 0.145267963409

结论:

  • join 仍然战胜concat,但微不足道
  • 列表理解比循环快(构建列表时
  • 加入生成器比加入列表慢
  • 其他方法没有用(除非您正在做一些特别的事情)

py3:

import sys
import timeit
from io import StringIO
from array import array


def test_concat():
    out_str = ''
    for _ in range(loop_count):
        out_str += 'abc'
    return out_str


def test_join_list_loop():
    str_list = []
    for _ in range(loop_count):
        str_list.append('abc')
    return ''.join(str_list)


def test_array():
    char_array = array('b')
    for _ in range(loop_count):
        char_array.frombytes(b'abc')
    return str(char_array.tostring())


def test_string_io():
    file_str = StringIO()
    for _ in range(loop_count):
        file_str.write('abc')
    return file_str.getvalue()


def test_join_list_compr():
    return ''.join(['abc' for _ in range(loop_count)])


def test_join_gen_compr():
    return ''.join('abc' for _ in range(loop_count))


loop_count = 80000

print(sys.version)

res = {}

for k, v in dict(globals()).items():
    if k.startswith('test_'):
        res[k] = timeit.timeit(v, number=10)

for k, v in sorted(res.items(), key=lambda x: x[1]):
    print('{:.5f} {}'.format(v, k))

结果

3.7.5 (default, Nov  1 2019, 02:16:32) 
[Clang 11.0.0 (clang-1100.0.33.8)]
0.03738 test_join_list_compr
0.05681 test_join_gen_compr
0.09425 test_string_io
0.09636 test_join_list_loop
0.11976 test_concat
0.19267 test_array

2
MutableString类在python 2.6中已被弃用,而在Python 3中已被完全删除,这可能毫无价值。请看这里
Adam Oren 2015年

1
警告!CPython优化此功能的声明不再适用于最新版本(v3.5-v3.8 +)。替换为这样的警告:以这种方式连接不可变对象始终是二次方:docs.python.org/3/library/stdtypes.html
jtschoonhoven

@jtschoonhoven:我已经把帖子变成了CW,请编辑您的评论。谢谢!
乔治

14

取决于您要做什么。如果您想要可变的序列,则内置list类型是您的朋友,并且从str到list再返回很简单:

 mystring = "abcdef"
 mylist = list(mystring)
 mystring = "".join(mylist)

如果要使用for循环构建大字符串,则pythonic方法通常是构建字符串列表,然后使用适当的分隔符(换行符或其他)将它们连接在一起。

另外,您还可以使用某些文本模板系统,解析器或任何最适合该工作的专用工具。


是“” .join(mylist)O(n)的复杂度吗?

@ user2374515是的,str.join()方法的复杂度为O(n)。根据官方文档:“对于性能敏感的代码,最好使用str.join()确保版本和实现之间一致的线性串联性能的方法。”
塞西尔·库里

11

也许使用一个bytearray

In [1]: s = bytearray('Hello World')

In [2]: s[:5] = 'Bye'

In [3]: s
Out[3]: bytearray(b'Bye World')

In [4]: str(s)
Out[4]: 'Bye World'

使用字节数组的吸引力在于其内存效率高和语法方便。它也可以比使用临时列表更快:

In [36]: %timeit s = list('Hello World'*1000); s[5500:6000] = 'Bye'; s = ''.join(s)
1000 loops, best of 3: 256 µs per loop

In [37]: %timeit s = bytearray('Hello World'*1000); s[5500:6000] = 'Bye'; str(s)
100000 loops, best of 3: 2.39 µs per loop

请注意,速度的大部分差异可归因于容器的创建:

In [32]: %timeit s = list('Hello World'*1000)
10000 loops, best of 3: 115 µs per loop

In [33]: %timeit s = bytearray('Hello World'*1000)
1000000 loops, best of 3: 1.13 µs per loop

这将使用什么编码?在Java中,类似的构造会非常成问题,因为它们使用平台默认编码,可以是任何形式...
Joachim Sauer

@JoachimSauer:像一样str,编码取决于您。至于bytearray而言,每个值仅仅是一个字节。
unutbu

字节数组对于真正的低级内容很有用-顾名思义,它实际上是关于“字节数组”,而不是“字符串字符串”。
bruno desthuilliers 2013年

“ ...但是比使用临时列表要慢。” 什么是临时清单?是(Python的默认)列表['s', 't', 'r', 'i', 'n', 'g']吗?
fikr4n 2014年

@BornToCode:临时名单将mylist布鲁诺desthuilliers'代码
unutbu 2014年

6

先前提供的答案几乎总是最好的。但是,有时字符串是在许多方法调用和/或循环中构建的,因此构建行列表然后将其联接不一定是很自然的事情。而且,由于不能保证您使用的是CPython,或者不能保证将使用CPython的优化,因此一种替代方法是仅使用print

这是一个示例帮助程序类,尽管该帮助程序类是微不足道的,并且可能是不必要的,但它有助于说明该方法(Python 3):

import io

class StringBuilder(object):

    def __init__(self):
        self._stringio = io.StringIO()
    
    def __str__(self):
        return self._stringio.getvalue()
    
    def append(self, *objects, sep=' ', end=''):
        print(*objects, sep=sep, end=end, file=self._stringio)

sb = StringBuilder()
sb.append('a')
sb.append('b', end='\n')
sb.append('c', 'd', sep=',', end='\n')
print(sb)  # 'ab\nc,d\n'


2

只是我在python 3.6.2上运行的一个测试显示“ join”仍然可以赢得大奖!

from time import time


def _with_format(i):
    _st = ''
    for i in range(0, i):
        _st = "{}{}".format(_st, "0")
    return _st


def _with_s(i):
    _st = ''
    for i in range(0, i):
        _st = "%s%s" % (_st, "0")
    return _st


def _with_list(i):
    l = []
    for i in range(0, i):
        l.append("0")
    return "".join(l)


def _count_time(name, i, func):
    start = time()
    r = func(i)
    total = time() - start
    print("%s done in %ss" % (name, total))
    return r

iterationCount = 1000000

r1 = _count_time("with format", iterationCount, _with_format)
r2 = _count_time("with s", iterationCount, _with_s)
r3 = _count_time("with list and join", iterationCount, _with_list)

if r1 != r2 or r2 != r3:
    print("Not all results are the same!")

输出为:

with format done in 17.991968870162964s
with s done in 18.36879801750183s
with list and join done in 0.12142801284790039s

1
如您所见,使用printf和.format连接字符串的效率更低。
Gringo Suave

1

我在Roee Gavirel的代码中添加了2个其他测试,这些测试最终表明,将列表连接到字符串并不比s + =“ something”快。

结果:

Python 2.7.15rc1    

Iterations: 100000
format    done in 0.317540168762s
%s        done in 0.151262044907s
list+join done in 0.0055148601532s
str cat   done in 0.00391721725464s

Python 3.6.7

Iterations: 100000
format    done in 0.35594654083251953s
%s        done in 0.2868080139160156s
list+join done in 0.005924701690673828s
str cat   done in 0.0054128170013427734s
f str     done in 0.12870001792907715s

码:

from time import time


def _with_cat(i):
    _st = ''
    for i in range(0, i):
        _st += "0"
    return _st


def _with_f_str(i):
    _st = ''
    for i in range(0, i):
        _st = f"{_st}0"
    return _st


def _with_format(i):
    _st = ''
    for i in range(0, i):
        _st = "{}{}".format(_st, "0")
    return _st


def _with_s(i):
    _st = ''
    for i in range(0, i):
        _st = "%s%s" % (_st, "0")
    return _st


def _with_list(i):
    l = []
    for i in range(0, i):
        l.append("0")
    return "".join(l)


def _count_time(name, i, func):
    start = time()
    r = func(i)
    total = time() - start
    print("%s done in %ss" % (name, total))
    return r


iteration_count = 100000

print('Iterations: {}'.format(iteration_count))
r1 = _count_time("format   ", iteration_count, _with_format)
r2 = _count_time("%s       ", iteration_count, _with_s)
r3 = _count_time("list+join", iteration_count, _with_list)
r4 = _count_time("str cat  ", iteration_count, _with_cat)
r5 = _count_time("f str    ", iteration_count, _with_f_str)

if len(set([r1, r2, r3, r4, r5])) != 1:
    print("Not all results are the same!")

1
Hooray并感谢部门的“有时简单的方法是最好的方法”。
Lance Kind,

0

在最重要的答案中,“ Python中的有效字符串连接”中的链接不再链接至预期的页面(而是重定向到tensorflow.org)。但是,此页面(引用了确切的代码)来自2004年,可能表示该页面https://waymoot.org/home/python_string/

您可能已经看过,因为它首先出现在Google上:

         efficient python StringBuilder

我无法对此发表评论,因为我没有特权。


1
我将上面的原始答案保留为未经编辑的状态,以记录Stackoverflow上的愚蠢人员如何否决添加了有用链接的答案。同时,“ Python中的有效字符串连接”不再重定向到tensorflow.org,因为skymind.com crunchbase.com/organization/skymind似乎已更名为welcome.ai/skymind
chars
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.