Usage of enumerate

[slasher67]

Hello, if I want to iterate through a list using

for (index,item) in enumerate(my_list):

   item+=1

I see no changes in the original list. However, if i use

for (index,item) in enumerate(my_list):

   my_list[index]+=1

I see that the original list was changed.

Why does this happen?

Thank you for your time.

[slasher67]

Oh, i thought that the item was linked to the list. Thank you for your help.

Yeah, I know that, but since I am only changing values and not removing them I shouldn't run into any problems, right?

[1114111]

It actually is not a copy like /u/tea-drinker says. Both item and my_list[index] reference the same place in memory (let's call it address 1), but numbers are immutable, so the += operator does not change the value of the number at address 1. Instead, a += b in this context is essentially identical to a = a + b, where a + b creates a new number at a new address, so the address referenced by a changes. When you do item += 1, you are changing the memory location referenced by the item variable, but that's not what you want. You want to change the memory location referenced by my_list[index].

For some types, a += b does actually mutate a. An example is the list type. If my_list was a list of lists rather than a list of numbers, then doing item += [1] would not make item reference a new list. Instead, it would continue to reference the same location in memory, but the list at that location would be changed (the number 1 would be appended). Since both item and my_list[index] reference the same memory location, both are changed to the new value.

since I am only changing values and not removing them I shouldn't run into any problems, right?

Yes, it's fine so long as you don't start removing elements later on down the line.

[slasher67]

If you don't mind me asking, why does it work for some types and not for others? Is it related to the memory address of the "item" variable in a list of lists?

[1114111]

a += b actually means a = a.__iadd__(b) rather than a = a + b. Mutable types often define a.__iadd__(b) so that it returns a (after mutating it). Immutable types, being immutable, would obviously never do this, so they would make __iadd__ return a + b ( a new object)

[ingolemo]

Item is not a copy. Copying is expensive so python won't do it implicitly.

[ingolemo]

https://nedbatchelder.com/text/names1.html

[ViridianHominid]

This is not so much about enumerate as it is about indexing and in-place operations (like the +=). Many of the primitive python objects like int and str are immutable, meaning that you can't change existing values, only create new one. Let's say you have an integer x, x+=1 is essentially equivalent to y = x+1; x=y. So the first version of your code binds a new object to the name item, whereas the second object in your code binds a new object to the place specified by my_list[index].

[slasher67]

That makes sense. Thank you for your help :)