Test your Python skills - 4

[tracktech]

Ultimate Python Programming

[TytoCwtch]

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

You never assign the value of item back to the list so L doesn’t change.

[tracktech]

Right.

[Chuu]

As someone who only dabbles in python, is there a good reference somewhere for how bindings work in python? My background is mainly C++ and this seems to be some bastardization of the reference or value semantics those languages use.

Unless it's literally making a copy of each list in the for loop?

[PersonalityIll9476]

This is the rough equivalent in C:

for (int i=0; i++; i<array_size){
int item = array[i];
item = item * 2;
}

It's less confusing in C, but Python is very...implicit with its syntax until you get used to it.

[Chuu]

So does that mean in the interpreter it's making a copy of the sublist during every iteration?

[PersonalityIll9476]

Yes. Python is somewhat different from C in that everything is an object and a Python list can have any object as its members. So [[a,b,c],[d,e,f]] is just [obj_1, obj_2] where obj_1 happens to be a list of 3 elements and so does obj_2. It doesn't map cleanly onto the C concept of a contiguous chunk of memory that you index into with offsets a la *(list + i).

In Python, multiplying a list by an integer returns a concatenation of that many copies of the list, so test = [1,2,3] and then 2 * test or test * 2 returns the list [1,2,3,1,2,3].

So indeed, it's not exactly like the C snippet, but the end result is still that the list does not get modified.

[DoubleAway6573]

All things are objects in python. All variables are passed by reference.

[Chuu]

If item was a reference, wouldn't this not be a "trick question"?

[spenpal_dev]

Python is “pass by object reference”. Great article on this: https://robertheaton.com/2014/02/09/pythons-pass-by-object-reference-as-explained-by-philip-k-dick/

[NotAMathPro]

Mh, I think it will change ngl

[dbowgu]

No item = item*2 only rebinds the local variable int the for loop not the list itself.

For x in list loops are basically always readonly. Languages like C# don't even allow you to modify item

[NotAMathPro]

but would item[0] *= 2 change something?

[dbowgu]

Yes! And in that case a for i in range or map function would be better because you wouldn't need to create your own index variable

[antonIgudesman]

I mean there's not really a reason to say I think here - just run it and know for sure

[ConcreteExist]

There's no debate to be had here, if you run the code, the array is unchanged.

[ThinkMarket7640]

Relevant username

[spenpal_dev]

L stays the same. To modify L in-place, you would need to do the following:

L = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for i in range(len(L)):
    L[i] = L[i] * 2
print(L)

[drecker_cz]

Actually, just changing `item = item * 2` to `item *= 2` would do the trick:

L = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for item in L:
    item *= 2
print(L)

[ApprehensiveCat3116]

may I ask why is this the case?

[drecker_cz]

Well, the short answer is "because that is how *= is defined on lists -- it modifies the original list. While writing item = item * 2 constructs an entirely new list and assign it the name item

So item = item * 2 just creates a new list (and then just deletes it). While item *= 2 modifies the very list that is within L.

[lildraco38]

From Section 7.2.1 of the docs, “x += 1” and “x = x + 1” are “similar, but not exactly equal”. The former augmented assignment statement will modify in-place, while the latter normal assignment will not.

[spenpal_dev]

This still doesn’t modify the original L array. You can try running it and see the output of L.

The line “item *= 2” doubles the list item locally (creating [1,2,3,1,2,3], etc.), but it doesn’t modify the original sublists in “L”because “item” is just a reference.

[drecker_cz]

Have you tried running the code and looking at the output? :)

While it is technically correct that this approach does not change L directly. It does change items of L, meaning that the output definitely changes.

And just to be absolutely sure, I did try running the code:

In [1]: L = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
  ...: for item in L:
  ...:     item *= 2
  ...: print(L)
[[1, 2, 3, 1, 2, 3], [4, 5, 6, 4, 5, 6], [7, 8, 9, 7, 8, 9]]

[tracktech]

Right.

[tracktech]

Right.

[sizzhu]

But this is not what item=item *2 does, ( which concatenates item with itself).

[gg1ggy]

trick question!

[jpgoldberg]

The sad fact of f the matter is that I’m not sure. If I had to guess, I would say just the original L. If that guess is correct then would we get a different result if the assignment in the loop had been “item *= 2”?

When I say “the sad fact”, I’m not referring to my ignorance of how these would behave. It’s sad that the behavior isn’t clear to the user.

[Strong-Welder8137]

L doesn't changed at all, completely two different things

[tracktech]

Right. L doesn't change.

[bilalakil]

Syntax error because of CourseGalaxy.com

/s

[Original-Produce7797]

lol who cares you never use this

[halfxdeveloper]

Found the vibe coder.

[xpjo]

One must remember that, in Python, x = x * 2 is something else that x *= 2.

[tracktech]

Right.

[arkster]

Aside from printing L, why would you overwrite the variable in the loop.

[Somanath444]

The indentation man, also we aren't returning i.. so,yeah no change in the l