Modify subclassed string in place

Question

I've got the following string subclass:

class S(str):
    def conc(self, next_val, delimiter = ' '):
        """Concatenate values to an existing string"""
        if not next_val is None:
            self = self + delimiter + next_val
        return self

I expect this to work as follows:

>>> x = S("My")
>>> x.conc("name")
'My name'
>>> x
'My name'

Instead I get this:

>>> x = S("My")
>>> x.conc("name")
'My name'
>>> x
'My'

Is there a way to modify the string in place? I think this gets into the difference between mutable and immutable strings. Subclassing seems to be the correct way to treat strings as mutable objects (at least according to the python docs) but I think I'm missing some key piece in my implementation.

Answer 1

You can't do what you're asking, because strings are immutable. The docs tell you to wrap the str class; that is, to make a class with an attribute which is the current value of the "mutable string". This exists in the standard library of Python 2.x as UserString.MutableString (but is gone in Python 3); it's pretty easy to write, though:

class MutableString(object):
    def __init__(self, value):
        self.value = value

    def conc(self, value, delim=' '):
        self.value = "{self.value}{delim}{value}".format(**locals())

    def __str__(self):
        return self.value

however, a better plan is to use a StringIO. In fact, you can get pretty close to the functionality that you wanted by subclassing StringIO (note that you need to use the pure Python version not the C version to do this, and that it's an old-style class so you can't use super). This is neater, faster, and altogether IMO more elegant.

>>> from StringIO import StringIO as sIO
>>> class DelimitedStringIO(sIO):
...     def __init__(self, initial, *args, **kwargs):
...             sIO.__init__(self, *args, **kwargs)
...             self.write(initial)
...
...     def conc(self, value, delim=" "):
...             self.write(delim)
...             self.write(value)
...
...     def __str__(self):
...             return self.getvalue()
...
>>> x = DelimitedStringIO("Hello")
>>> x.conc("Alice")
>>> x.conc("Bob", delim=", ")
>>> x.conc("Charlie", delim=", and ")
>>> print x
Hello Alice, Bob, and Charlie

You can override __repr__ if you want x to look even more like a string, but this is bad practice, since where possible __repr__ is meant to return a description in Python of the object.

Answer 2

The line self = self + delimiter + next_val is creating a new variable self and assigning the result of self + delimiter + next_val to this. To achieve what you want you need to apply the operation directly to the self variable. But since strings are immutable, you can't do this. This is exactly why all strs methods return a new string rather than modifying the strings they operate on.

So sorry, you can't do what you're trying to accomplish.

Answer 3

Python strings (and anything inheriting from them) are immutable.

There is a class called MutableString in UserString module that might do what you want.

If you are using a recent (as in 2.7/3.1) version of python you can also look at bytearray, though it got it's own set of limits and quirks.