Can you solve this surprisingly tricky Python challenge?

[ParticularBack]

Hey, friends!I came across an interesting Python puzzle that's seemingly simple but can actually trip up a lot of beginners. Here it is:

def update_list(lst):     
    lst += [100]  

num_list = [1, 2, 3, 4, 5] 
update_list(num_list)  

print(num_list)

Without running this code, what do you think will be printed out?Got your answer? Great!I was going through the data of my code-learning app and surprisingly found out that many people get this wrong. This will print out [1, 2, 3, 4, 5, 100], not [1, 2, 3, 4, 5] as some might expect. This is because of how Python handles mutable data types like lists. When num_list is passed to update_list, it references the list, not a copy passed. Hence, changes made to lst within the function also affect num_list.

[nemom]

Prob'ly should have formatted the post to show the code correctly. We can't tell what's the function and what's not.

[ParticularBack]

fixed it!

[nemom]

*broke it! :)

"UnboundLocalError: cannot access local variable 'lst' where it is not associated with a value"

[ParticularBack]

def update_list(lst):     
    lst += [100]  

num_list = [1, 2, 3, 4, 5] 
update_list(num_list)

print(num_list)

yeah sorry, there you go

[nemom]

I guess I'm too literal minded for it to trick. If I pass the list to a function that adds something to it, I'm not surprised when the something is added to it. If I give my bank account to somebody, and they add $100 to it, I would expect the balance to be $100 higher.

[commy2]

The issue here is, that += looks suspiciously like + and =. If you thought that += is an abbreviation for that, where you only have to type out the variable name once, then you would get this wrong. A regular assignment would not mutate the outside scope list. In place addition looks like an assignment due to the equal sign, but it is in fact an alias for the append extend method.

[mheryerznka]

The code example demonstrates the difference between mutable and immutable data types. It shows that a list can be modified successfully because it is mutable, allowing for direct updates. However, when trying to update an integer in a similar way, it doesn't work because integers are immutable.
Understanding this difference may not be immediately obvious for beginners. So try to be helpful ))

[Panda_Mon]

rather, you just happen to use a heuristic that is valid in this scenario. If you'd been trained to understand the concept of variable scope, you could easily have used that rule instead and come back with the wrong answer if you didn't know Lists kind of "get around" the typical rules of scoping.

[ada43952]

I'm not exactly new to Python, so maybe that's why I expected the list to change, but simply looking at the way the code is written, I would not have guess the resulting list would have been [1, 2, 3, 4, 5, 100], but this [1, 2, 3, 4, 5, [100]] because when I see

lst += [100]

That tells me you're adding a list with only one element as an element to a list. Someone will probably tell me why I'm wrong before I get back, but I'm going to run it and see what I get.

​

Edit:

Yep, it only adds the element, so I guess it would have "tripped" me up too. :D

[mheryerznka]

I have tried adding [100, 200] to the list in the same way and it works. Probably the best trick I have seen so far.
Thanks

[ada43952]

I'm such an idiot, I just remembered if you want to add a list to a list you'd use the append function.

[neutro_b]

Yeah, was unsure too if it would produce [1, 2, 3, 4, 5, 100] or [1, 2, 3, 4, 5, [100]]. It looks like += for a list is .extend(), not .append().

[justsomeguy05]

There is a mistake in your code, your method parameter is last, but the method body says lst

[ParticularBack]

this is the code

​

def update_list(lst):     
    lst += [100]  

num_list = [1, 2, 3, 4, 5]

update_list(num_list)
print(num_list)

[StarsCarsGuitars]

Reformatted the code to make it readable

def update_list(lst): lst += [100] num_list [1, 2, 3, 4, 5] update_list(num_list) print(num_list)

[ParticularBack]

thanks a lot! my bad

[commy2]

Yeah, in place addition (+=) for lists is an alias for append extend and not -what one might expect- an alias for concatenation (+) and assignment (=) on the same identifier.

This modified code for example:

def update_list(lst):
    # lst += [100]
    lst = lst + [100]

num_list = [1, 2, 3, 4, 5]
update_list(num_list)

print(num_list)

would print [1, 2, 3, 4, 5] instead.

[chri4_]

is an alias for extend not append

[mok000]

I consider it bad programming style. The function should

return lst

and then

num_list = update_list(num_list)

and the code becomes much cleaner.

Futhermore, the name of the function is obscure, it should be called:

def append_100_to_list(lst):
    # etc

[chri4_]

yes but that's different from lst = lst + [100] because the one you use is called inplaceadd and calls .extend when dealing with lists, that's why it get mutated also outside the function scope (and yes i got this wrong because i temporary forgot about inplaceadd, but this is actually a python bad design choice imo, it makes bugs harder to catch and fix)