Cadenas mutables en Python

Question

Por favor, ¿sabe de una biblioteca Python que proporciona cadenas mutables? Google arrojó sorprendentemente pocos resultados. La única biblioteca utilizable que encontré es http://code.google.com/p/gapbuffer/ que está en C, pero preferiría que estuviera escrita en Python puro.

Editar: Gracias por las respuestas, pero estoy buscando una biblioteca eficiente. Es decir, ''.join(list) podría funcionar, pero esperaba algo más optimizado. Además, tiene que admitir las cosas habituales que hacen las cadenas regulares, como regex y unicode.

Answer 1

En Python mutable tipo de secuencia es bytearray ver this link

Answer 2

class MutableString(object): 
    def __init__(self, data): 
     self.data = list(data) 
    def __repr__(self): 
     return "".join(self.data) 
    def __setitem__(self, index, value): 
     self.data[index] = value 
    def __getitem__(self, index): 
     if type(index) == slice: 
      return "".join(self.data[index]) 
     return self.data[index] 
    def __delitem__(self, index): 
     del self.data[index] 
    def __add__(self, other): 
     self.data.extend(list(other)) 
    def __len__(self): 
     return len(self.data) 

... y así sucesivamente, y así sucesivamente.

También podría establecer la subclase StringIO, buffer o bytearray.

Answer 3

Esto le permitirá cambiar de manera eficiente los caracteres en una cadena. Aunque no puedes cambiar la longitud de la cadena.

>>> import ctypes 

>>> a = 'abcdefghijklmn' 
>>> mutable = ctypes.create_string_buffer(a) 
>>> mutable[5:10] = ''.join(reversed(list(mutable[5:10].upper()))) 
>>> a = mutable.value 
>>> print `a, type(a)` 
('abcdeJIHGFklmn', <type 'str'>) 

Answer 4

¿Qué hay de simplemente subclasificar list (el principal ejemplo de la mutabilidad en Python)?

class CharList(list): 

    def __init__(self, s): 
     list.__init__(self, s) 

    @property 
    def list(self): 
     return list(self) 

    @property 
    def string(self): 
     return "".join(self) 

    def __setitem__(self, key, value): 
     if isinstance(key, int) and len(value) != 1: 
      cls = type(self).__name__ 
      raise ValueError("attempt to assign sequence of size {} to {} item of size 1".format(len(value), cls)) 
     super(CharList, self).__setitem__(key, value) 

    def __str__(self): 
     return self.string 

    def __repr__(self): 
     cls = type(self).__name__ 
     return "{}(\'{}\')".format(cls, self.string) 

Esto solo une la lista a una cadena si desea imprimirla o solicitar activamente la representación de la cadena. Mutar y extender son triviales, y el usuario ya sabe cómo hacerlo, ya que es solo una lista.

Ejemplo de uso:

s = "te_st" 
c = CharList(s) 
c[1:3] = "oa" 
c += "er" 
print C# prints "toaster" 
print c.list # prints ['t', 'o', 'a', 's', 't', 'e', 'r'] 

está fijado el siguiente, véase la actualización a continuación.

Hay una advertencia (que se puede solucionar): no hay ningún control (todavía) de que cada elemento sea de hecho un carácter. Por lo menos fallará la impresión para todo menos para cadenas. Sin embargo, aquellos que se pueden unir y puede causar situaciones extrañas como esta: [véase el ejemplo de código siguiente]

Con la costumbre __setitem__, la asignación de una cadena de longitud = 1 a un elemento de CharList elevará un ValueError!. Todo lo demás se puede asignar libremente, pero aumentará un TypeError: sequence item n: expected string, X found al imprimir, debido a la operación string.join(). Si eso no es lo suficientemente bueno, más controles pueden ser fácilmente añadidos (potencialmente también para __setslice__ o cambiando la clase base a collections.Sequence (rendimiento puede ser diferente ?!), cf. here)

s = "test" 
c = CharList(s) 
c[1] = "oa" 
# with custom __setitem__ a ValueError is raised here! 
# without custom __setitem__, we could go on: 
c += "er" 
print C# prints "toaster" 
# this looks right until here, but: 
print c.list # prints ['t', 'oa', 's', 't', 'e', 'r']