Modify subclassed string in place

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.

Solution

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.