Python equivalent of Java StringBuffer?

Python equivalent of Java StringBuffer?

Python 3

From the docs:

Concatenating immutable sequences always results in a new object. This means that building up a sequence by repeated concatenation will have a quadratic runtime cost in the total sequence length. To get a linear runtime cost, you must switch to one of the alternatives below:
if concatenating str objects, you can build a list and use str.join() at the end or else write to an io.StringIO instance and retrieve its value when complete

Experiment to compare runtime of several options:

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):
    return .join(str_list)

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

def test_string_io():
    file_str = StringIO()
    for _ in range(loop_count):
    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


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

Python 2

Efficient String Concatenation in Python is a rather old article and its main statement that the naive concatenation is far slower than joining is not valid anymore, because this part has been optimized in CPython since then. From the docs:

CPython implementation detail: If s and t are both strings, some Python implementations such as CPython can usually perform an in-place optimization for assignments of the form s = s + t or s += t. When applicable, this optimization makes quadratic run-time much less likely. This optimization is both version and implementation dependent. For performance sensitive code, it is preferable to use the str.join() method which assures consistent linear concatenation performance across versions and implementations.

Ive adapted their code a bit and got the following results on my machine:

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):
    return char_array.tostring()

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

def method5():
    file_str = StringIO()
    for num in xrange(loop_count):
    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 still wins over concat, but marginally
  • list comprehensions are faster than loops (when building a list)
  • joining generators is slower than joining lists
  • other methods are of no use (unless youre doing something special)

Depends on what you want to do. If you want a mutable sequence, the builtin list type is your friend, and going from str to list and back is as simple as:

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

If you want to build a large string using a for loop, the pythonic way is usually to build a list of strings then join them together with the proper separator (linebreak or whatever).

Else you can also use some text template system, or a parser or whatever specialized tool is the most appropriate for the job.

Python equivalent of Java StringBuffer?

Perhaps use a bytearray:

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

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

In [3]: s
Out[3]: bytearray(bBye World)

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

The appeal of using a bytearray is its memory-efficiency and convenient syntax. It can also be faster than using a temporary list:

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

Note that much of the difference in speed is attributable to the creation of the container:

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

Leave a Reply

Your email address will not be published.