comment puis-je effacer un stringio objet?

TL;DR

N'est pas la peine de compensation, il suffit de créer un nouveau—c'est plus rapide.

La méthode

Python 2

Voici comment je pourrais trouver de telles choses:

>>> from StringIO import StringIO
>>> dir(StringIO)
['__doc__', '__init__', '__iter__', '__module__', 'close', 'flush', 'getvalue', 'isatty', 'next', 'read', 'readline', 'readlines', 'seek', 'tell', 'truncate', 'write', 'writelines']
>>> help(StringIO.truncate)
Help on method truncate in module StringIO:

truncate(self, size=None) unbound StringIO.StringIO method
    Truncate the file's size.

    If the optional size argument is present, the file is truncated to
    (at most) that size. The size defaults to the current position.
    The current file position is not changed unless the position
    is beyond the new file size.

    If the specified size exceeds the file's current size, the
    file remains unchanged.

Donc, vous voulez .truncate(0). Mais c'est probablement moins cher (et plus facile) à l'initialisation d'un nouveau StringIO. Voir ci-dessous pour les indices de référence.

Python 3

(Grâce à tstone2077 pour pointant la différence.)

>>> from io import StringIO
>>> dir(StringIO)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__lt__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setstate__', '__sizeof__', '__str__', '__subclasshook__', '_checkClosed', '_checkReadable', '_checkSeekable', '_checkWritable', 'close', 'closed', 'detach', 'encoding', 'errors', 'fileno', 'flush', 'getvalue', 'isatty', 'line_buffering', 'newlines', 'read', 'readable', 'readline', 'readlines', 'seek', 'seekable', 'tell', 'truncate', 'writable', 'write', 'writelines']
>>> help(StringIO.truncate)
Help on method_descriptor:

truncate(...)
    Truncate size to pos.

    The pos argument defaults to the current file position, as
    returned by tell().  The current file position is unchanged.
    Returns the new absolute position.

Il est important de noter à ce que maintenant la position courante dans le fichier est inchangé, alors que la troncation de la taille zéro serait réinitialiser la position dans le Python 2 variante.

Ainsi, pour Python 2, vous avez seulement besoin

>>> from cStringIO import StringIO
>>> s = StringIO()
>>> s.write('foo')
>>> s.getvalue()
'foo'
>>> s.truncate(0)
>>> s.getvalue()
''
>>> s.write('bar')
>>> s.getvalue()
'bar'

Si vous le faites en Python 3, vous n'obtiendrez pas le résultat que vous attendiez:

>>> from io import StringIO
>>> s = StringIO()
>>> s.write('foo')
3
>>> s.getvalue()
'foo'
>>> s.truncate(0)
0
>>> s.getvalue()
''
>>> s.write('bar')
3
>>> s.getvalue()
'\x00\x00\x00bar'

Donc en Python 3, vous aussi besoin de réinitialiser la position:

>>> from cStringIO import StringIO
>>> s = StringIO()
>>> s.write('foo')
3
>>> s.getvalue()
'foo'
>>> s.truncate(0)
0
>>> s.seek(0)
0
>>> s.getvalue()
''
>>> s.write('bar')
3
>>> s.getvalue()
'bar'

Si à l'aide de la truncate méthode en Python 2 code, il est plus prudent d'appeler seek(0) en même temps (avant ou après, il n'a pas d'importance), de sorte que le code ne sera pas casser lorsque vous inévitablement port à Python 3. Et il y a une autre raison pourquoi vous devriez vous suffit de créer un nouveau StringIO objet!

Fois

Python 2

>>> from timeit import timeit
>>> def truncate(sio):
...     sio.truncate(0)
...     return sio
... 
>>> def new(sio):
...     return StringIO()
... 

Quand il est vide, avec StringIO:

>>> from StringIO import StringIO
>>> timeit(lambda: truncate(StringIO()))
3.5194039344787598
>>> timeit(lambda: new(StringIO()))
3.6533868312835693

Avec 3 KO de données, avec StringIO:

>>> timeit(lambda: truncate(StringIO('abc' * 1000)))
4.3437709808349609
>>> timeit(lambda: new(StringIO('abc' * 1000)))
4.7179079055786133

Et la même chose avec cStringIO:

>>> from cStringIO import StringIO
>>> timeit(lambda: truncate(StringIO()))
0.55461597442626953
>>> timeit(lambda: new(StringIO()))
0.51241087913513184
>>> timeit(lambda: truncate(StringIO('abc' * 1000)))
1.0958449840545654
>>> timeit(lambda: new(StringIO('abc' * 1000)))
0.98760509490966797

Donc, en ignorant les éventuels problèmes de mémoire (del oldstringio), il est plus rapide de tronquer une StringIO.StringIO (3% plus rapide pour le vide, 8% plus rapide pour les 3 KO de données), mais il est plus rapide ("fasterer" trop) pour créer un nouveau cStringIO.StringIO (8% plus rapide pour le vide, 10% plus rapide pour les 3 KO de données). Donc, je vous recommande simplement à l'aide de la plus simple—donc, en supposant que vous travaillez avec Disponible, utilisez cStringIO et en créer de nouveaux.

Python 3

Le même code, juste avec seek(0) mettre en.

>>> def truncate(sio):
...     sio.truncate(0)
...     sio.seek(0)
...     return sio
... 
>>> def new(sio):
...     return StringIO()
...

Quand il est vide:

>>> from io import StringIO
>>> timeit(lambda: truncate(StringIO()))
0.9706327870007954
>>> timeit(lambda: new(StringIO()))
0.8734330690022034

Avec 3 KO de données:

>>> timeit(lambda: truncate(StringIO('abc' * 1000)))
3.5271066290006274
>>> timeit(lambda: new(StringIO('abc' * 1000)))
3.3496507499985455

Donc pour Python 3 en créer un nouveau au lieu de réutiliser un vide est 11% plus rapide et la création d'un nouveau lieu de la réutilisation d'un 3K est 5% plus rapide. Encore une fois, créer un nouveau StringIO plutôt que de tronquer et de la recherche.

Comment j'ai réussi à optimiser mon traitement (lire en morceaux, chaque morceau, écrire des traités flux de sortie vers un fichier) de nombreux fichiers dans une séquence, c'est que je réutiliser le même cStringIO.StringIO exemple, mais toujours reset() après utilisation, puis écrire, et puis truncate(). En faisant cela, je suis le seul à en tronquant la partie à la fin que je n'ai pas besoin pour le fichier en cours. Cela semble m'ont donné un ~3% d'augmentation des performances. Quelqu'un qui est plus expert sur ce qui pourrait confirmer si cela optimise l'allocation de mémoire.

sio = cStringIO.StringIO()
for file in files:
    read_file_chunks_and_write_to_sio(file, sio)
    sio.truncate()
    with open('out.bla', 'w') as f:
        f.write(sio.getvalue())
    sio.reset()