Why are strings immutable?

[Brent W. Hughes]

I kind of hate to have to convert a string into a list, manipulate it, and
then convert it back into a string. Why not make strings mutable?

 

[Sam Holden]

I kind of hate to have to convert a string into a list, manipulate it, and
then convert it back into a string. Why not make strings mutable?

Not being able to use strings as dictionary keys would kind of suck

 

[Peter Hansen]

I kind of hate to have to convert a string into a list, manipulate it, and
then convert it back into a string. Why not make strings mutable?

It is unlikely you are doing whatever it is you need to do
in the best way possible if you are converting to a list and
back. What's the use case here? Can you describe what you
need to accomplish without reference to how you think it should
be accomplished? Maybe there's a better way...

-Peter

 

[Byron]

Hi Brent,

It is usually best to create a function in which you can
1) pass the string to
2) change it as needed
3) return the modified sting back to the original caller.

Can you tell us a little more about what you are trying to accomplish?

Byron

 

[John Roth]

I kind of hate to have to convert a string into a list, manipulate it, and
then convert it back into a string. Why not make strings mutable?

Strings are immutable because they are "value objects".
Consult any good, recent OO design text for what a
value object is, and why it should be immutable.

That said, it would be useful to have a
string buffer object that could be changed.

John Roth

 

[Christos TZOTZIOY Georgiou]

That said, it would be useful to have a
string buffer object that could be changed.

array.array('c') is a close substitute.

 

[Leif K-Brooks]

That said, it would be useful to have a
string buffer object that could be changed.

What about StringIO?

 

[Brent W. Hughes]

Let me give two examples of where I think it would be nice to be able to
change strings in place:


First example:

I want to add about 20,000 words to the end of a string, something like
this:

Str = [ ]
for i in range(20000):
Word = DoSomeProcessing()
Str += Word

I'd actually like to say Str.extend(Word). As it is, I'm thinking of
something like this:

List = [ ]
for i in range(20000):
Word = DoSomeProcessing()
List.extend(list(Word))
Str = ''.join(List)


Second example:

I would like to reverse a string containing about 120,000 characters. I'd
like to do it in place, but I'm planning to do something like this:

List = list(Str)
List.reverse()
Str = ''.join(List)

 

[Hallvard B Furuseth]

Let me give two examples of where I think it would be nice to be able to
change strings in place:

Sure, it would be nice sometimes.
But immutable strings provide many nice advantages too.

I want to add about 20,000 words to the end of a string, something like
this:

Str = [ ]
for i in range(20000):
Word = DoSomeProcessing()
Str += Word

I'd actually like to say Str.extend(Word).

If you are doing a lot of that with the string, does it need to be a
single string? I've just speeded up a program significantly by changing
string_var = ...
string_var += ...
string_var += ...
...
to
array_var = ['string']
array_var.append(...)
array_var.append(...)
...
result = "".join(array_var)
(Well, because of how the data was structured I actually used a dict
which was unpacked to a list comprehension which was joined to a string,
but it still speeded things up.)

You might also speed things up with
append_string = array_var.append
append_string(...)
if it is too slow, since that saves a lot of attribute lookups. But
don't make your code more unreadable like that unless it _is_ too slow.

I would like to reverse a string containing about 120,000 characters. I'd
like to do it in place, but I'm planning to do something like this:

List = list(Str)
List.reverse()
Str = ''.join(List)

import array
a = array.array('c', Str)
a.reverse()
Str = a.tostring()

Still needs two new objects, but at least that's a lot fewer than your
list.

 

[Larry Bates]

Think about it. Since strings occupy a fixed
number of bytes in memory, a mutable string would
just be a linked list of strings. For performance
reasons you can't require that everything in memory
gets moved around when you want to add one byte to
a string. Multiply that by 20K and performance
would be terrible. Since a mutable string is just
a list of strings, Python just asks the programmer
to treat it exactly like what it REALLY is. If
you want to append lots of things to a string, build
a list and then join it into a string at the end
of processing.

Your example:

List = [ ]
for i in range(20000):
Word = DoSomeProcessing()
List.extend(list(Word))
Str = ''.join(List)


will work as:

words=[]
for i in xrange(20000):
word = DoSomeProcessing()
words.append(word)

word_string = ' '.join(words)

Notes:

1) You build the word_list by appending words that
come back frmo DoSomeProcessing().

2) If you want a space between your words you must
specify it as the character before .join() call.

3) range(20000) will create a list of length=20000
and interate over it, xrange(20000) will just create
an iterable object that returns the next number on
each sucessive call (saving both memory and the time
to create the 20K list).

4) You should stay FAR away from variables named
list or str (even though you capitalized the first
character). list and str are python functions that
can easily get redefined by accident. List and Str
will work, but I've seen MANY Python programmers walk
on list, str, dict by accident and later wonder why.

HTH,
Larry Bates
Syscon, Inc.

 

[Paul Rubin]

Think about it. Since strings occupy a fixed
number of bytes in memory, a mutable string would
just be a linked list of strings.

Eh? It would be treated just like Python currently treats lists.

In fact, array('B') does just about exactly what Brent is asking for.

 

[Jeff Shannon]

Your example:

List = [ ]
for i in range(20000):
Word = DoSomeProcessing()
List.extend(list(Word))
Str = ''.join(List)


will work as:

words=[]
for i in xrange(20000):
word = DoSomeProcessing()
words.append(word)

word_string = ' '.join(words)

Or even (using a list comp):

words = ' '.join( [DoSomeProcessing() for i in xrange(20000)] )

Though I have to wonder what you're doing with a 20,000 word string,
built programmatically word-by-word. While I don't know what you're
doing, here, the way you're building it seems to suggest to me that a
list or dictionary may actually be a more natural way to handle your data.

Jeff Shannon
Technician/Programmer
Credit International

 

[Jeremy Bowers]

If you are doing a lot of that with the string, does it need to be a
single string? I've just speeded up a program significantly by changing
string_var = ...
string_var += ...
string_var += ...
...
to
array_var = ['string']
array_var.append(...)
array_var.append(...)
...
result = "".join(array_var)
(Well, because of how the data was structured I actually used a dict which
was unpacked to a list comprehension which was joined to a string, but it
still speeded things up.)

For PyDS, I contributed a class that does that and offers a += interface,
so it is easy to drop in without too much conversion work. It is very
simple.

In general, you should not use this and you should do it "right" the first
time, but for existing code this can be a convenient make-do.

Replace your initial "myString = ''" with "myString = StringCollector()",
and depending on how you use this you may not need to change the final
use. Otherwise, call "str()" on your StringCollector.

(Note the encoding in iadd; I just added the locale call without testing
it, and you may want to switch it; PyDS actually uses its own system.)

-----------------------------

import locale
class StringCollector:

def __init__(self, string='', encoding = None):
self.buffer = StringIO()
if string: self += string
if encoding in None:
self.encoding = locale.getpreferredencoding()
else:
self.encoding = encoding

def __iadd__(self, other):
if type(string) == types.UnicodeType:
self.buffer.write(other.encode(self.encoding))
else:
self.buffer.write(other)
return self

def __repr__(self):
return '<StringCollector>'

def __str__(self):
return self.buffer.getvalue()