Python équivalent de Java StringBuffer?

Est-il rien en Python comme Java StringBuffer? Depuis les chaînes sont immuables en Python aussi, leur montage en boucle serait inefficace.

  • Vous pouvez obtenir un effet similaire en la construction d'une liste de chaînes de caractères et à l'aide de join() après la boucle. Mais je suis sûr qu'il ya plus pythonic moyen (impliquant probablement compréhension de liste).
InformationsquelleAutor user2902773 | 2013-11-12
  1. 61

    Efficace de Concaténation de Chaîne en Python est un vieux article et de ses principaux déclaration que les naïfs concaténation est beaucoup plus lent que de joindre n'est plus valable, parce que cette partie a été optimisé Disponible depuis:

    Disponible de mise en œuvre détail: Si s et t sont deux chaînes, certaines implémentations de Python comme Disponible pouvez généralement effectuer une optimisation pour les affectations de la forme s = s + t ou s += t. Le cas échéant, cette optimisation fait quadratique run-temps beaucoup moins probable. Cette optimisation est la version et la mise en œuvre dépend. Pour la performance sensible code, il est préférable d'utiliser la str.méthode join() qui assure la cohérence linéaire de concaténation de la performance de l'ensemble des versions et des mises en œuvre. @ http://docs.python.org/2/library/stdtypes.html

    J'ai adapté à leur code un peu et a obtenu les résultats suivants sur ma 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):
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)

    Résultats:

    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

    Conclusions:

    • join gagne encore plus de concat, mais de façon marginale
    • interprétations de la liste sont plus rapides que les boucles
    • rejoindre générateurs est plus lent que de rejoindre les listes de
    • d'autres méthodes sont d'aucune utilité (sauf si vous faites quelque chose de spécial)
    • Il peut être vaut la peine rien que le MutableString classe a été supprimée dans la version 2.6 de python et supprimé entièrement en Python 3. voir ici
    InformationsquelleAutor georg
  2. 11

    Dépend de ce que vous voulez faire. Si vous voulez une mutable séquence, le groupe builtin list type est votre ami, et va de str à la liste et à l'arrière est aussi simple que:

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

    Si vous voulez construire une chaîne de grande taille à l'aide d'une boucle for, l'pythonic moyen est généralement de créer une liste de chaînes de caractères puis de se joindre à eux avec le bon séparateur (saut de ligne ou quoi que ce soit).

    Sinon vous pouvez aussi utiliser du texte système de template, ou un analyseur ou que ce soit spécialisé est l'outil le plus approprié pour le travail.

    • C'est la complexité des "".join(maliste) O(n) ?
    • le str.join() méthode est O(n) la complexité. Par la documentation officielle: "Pour la performance sensible code, il est préférable d'utiliser le str.join() méthode qui assure compatible linéaire performances de concaténation dans les versions et mises en oeuvre."
    InformationsquelleAutor bruno desthuilliers
  3. 7

    Peut-être utiliser une 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'

    L'appel de l'aide d'un objet bytearray est sa mémoire et de l'efficacité pratique de la syntaxe. Il peut également être plus rapide que l'utilisation temporaire de la liste:

    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

    Noter qu'une grande partie de la différence de vitesse est attribuable à la création du conteneur:

    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
    • Ce que l'encodage de cette utilisation? En Java d'autres constructions similaires serait très problématique, car ils utilisent la plate-forme de codage par défaut qui peut être n'importe quoi ...
    • Comme un str, l'encodage est à vous. Aussi loin que l' bytearray est concerné, chaque valeur est juste un octet.
    • bytearray peut être utile pour les très bas niveau de stuff - comme son nom l'indique, c'est vraiment des "tableaux d'octets", pas de "chaînes de caractères".
    • "...mais il est plus lent que d'utiliser une liste temporaire." Ce qui est temporaire liste? Est-il (Python par défaut) de la liste, comme ['s', 't', 'r', 'i', 'n', 'g']?
    • De la temporaire de de la liste serait mylist dans bruno desthuilliers code.
    InformationsquelleAutor unutbu
  4. 5

    Précédemment fourni des réponses sont presque toujours le meilleur. Cependant, parfois, la chaîne est construite à travers de nombreux appels de méthode et/ou de boucles, de sorte qu'il n'est pas forcément naturel pour créer une liste de lignes et ensuite se joindre à eux. Et depuis il n'y a aucune garantie que vous utilisez Disponible ou Disponible d'optimisation doit s'appliquer, puis une autre approche consiste à n'utiliser que de l'imprimer!

    Voici un exemple de la classe helper, bien que la classe helper est trivial et sans doute inutile, il sert à illustrer l'approche (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'
    InformationsquelleAutor rhaertel80
  5. 2

    ce lien peut être utile pour la concaténation en python

    http://pythonadventures.wordpress.com/2010/09/27/stringbuilder/

    exemple de lien ci-dessus:

    def g():
sb = []
for i in range(30):
sb.append("abcdefg"[i%7])
return ''.join(sb)
print g()   
# abcdefgabcdefgabcdefgabcdefgab
    • Tandis que ceci peut théoriquement répondre à la question, il serait préférable pour inclure l'essentiel des éléments de réponse ici, et de fournir le lien de référence.
    InformationsquelleAutor Kamlesh Arya
  6. 2

    Juste un test, je tourne sur python 3.6.2 en montrant que "rejoindre" encore gagner GROS!

    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!")

    Et le résultat a été:

    with format done in 17.991968870162964s
with s done in 18.36879801750183s
with list and join done in 0.12142801284790039s
    • À l'aide de printf et .format de la concaténation de chaînes de caractères est encore moins efficace, comme vous l'avez trouvé.
    InformationsquelleAutor Roee Gavirel
  7. 0

    J'ai ajouté à Roee Gavirel code 2 tests supplémentaires qui montrent de façon concluante que l'adhésion à des listes de chaînes en est pas plus vite que le s += "quelque chose".

    Résultats:

    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

    Code:

    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!")
    InformationsquelleAutor Martlark