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"开发者_Python百科""
        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.

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.

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.

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.

There are no mutable strings. There are bytes/bytearrays and lists of one-character strings, which you could modify and then turn into a string. If you want to emulate a "mutable string", you'd have to keep a string in a private field, replace that and otherwise pretend you're that string (this is propably what MutableString does). Be warned, however: This will be highly inefficient and is propably not needed. Also, you can't always use mutable strings in place of immutable ones (e.g. as dict key). Why do you think you need a mutable string? The rest of us (and the Java and .NET guys) are getting along just fine without.

Your conc doesn't work because Python doesn't have pass-by-reference. self = ... doesn't change the current object, it just overwrites a local variable (self.member = ...) does work though, because that's a method call modifying some dictionary).

Here is an implementation of what you want to do:

class S(object):
    def __init__(self, val=""):
        self.data = val;

    def conc(self, next_val, delimiter = ' '):
        if not next_val is None:
            self.data = self.data + delimiter + next_val
        return self

    def __repr__(self):
        return self.data

You can extend this class with more methods.