Semantics of python loops and strings

Question

Consider:

args = ['-sdfkj']
print args
for arg in args:
    print arg.replace("-", '')
    arg = arg.replace("-", '')
print args

This yields:

['-sdfkj']
sdfkj
['-sdfkj']

Where I expected it to be ['sdfkj'].

Is arg in the loop a copy?

It behaves as if it is a copy (or perhaps an immutable thingie, but then I expect an error would be thrown...)

Note: I can get the right behavior with a list comprehension. I am curious as to the cause of the above behavior.

Answer 1

Is arg in the loop a copy?

Yes, it contains a copy of the reference.

When you reassign arg you aren't modifying the original array, nor the string inside it (strings are immutable). You modify only what the local variable arg points to.

Before assignment         After assignment

args          arg          args          arg
  |            |            |            |
  |            |            |            |
(array)        /          (array)       'sdfkj'
  |[0]        /             |[0]        
   \         /              |
    \       /               |
     '-sdfkj'            '-sdfkj'

Answer 2

Since you mention in your question that you know it can be done using list comprehensions, I'm not going to show you that way.

What is happening there is that the reference to each value is copied into the variable arg. Initially they both refer to the same variable. Once arg is reassigned, it refers to the newly created variable, while the reference in the list remains unchanged. It has nothing to do with the fact that strings are immutable in Python. Try it out using mutable types.

A non-list comprehension way would be to modify the list in place:

for i in xrange(len(args)):
    args[i]=args[i].replace('-','')
print args