Mutable vs. Immutable object specifically lists

Question

I have a question regarding the mutability of lists. I am currently going through a tutorial by YouTuber/Programmer sentdex and one of the issues that comes up is mutability vs. immutability of objects and lists.

Example 1:

x = [1]
print(id(x))

def test():
    x = [2]
test()
print(x)
print(id(x))

In this example x remains [1].

Example 2:

x = [1]
print(x)
print(id(x))
def test():
    x [0]= 2
test()
print(x)
print(id(x))

In this example x is changed to [2].

So my question is this, are lists only mutable when changing them via an index value inside of a specific function?

Thanks for your help!

I don't see why this is downvoted. This is a very confusing subject, and can use as much explanation as possible. — Acccumulation, May 30 '21 at 15:59

score 1 · Accepted Answer · answered May 30 '21 at 15:57

"Mutable" means that you can change a particular element within the object. With a nonmutable object, if you want a different value for a particular element, you have to re-assign the entire object. Lists always have the capability of changing a particular element. In your second example, the list is still mutable, but you aren't mutating it. you're re-assigning it.

In Python, when a function is called, the default behavior is for the scope of all variables names to be just within the function, but the function has full access to the objects. When you write x[0] = 2, you're accessing the actual object, and changing the first element of that object. When you write x = [2], you're no longer dealing with the same object, you're only dealing with the name "x", and the scope of the name is only within the function. If you had written global x in the function, however, then that would tell Python that you want the name "x" to have global scope, and it would reassign the name "x" to the new object [2] for the entire program. You would then see a different value for both x[0] and id(x) in the main program.

It's a rather difficult thing to explain, because the issue is the distinction between the name of an object versus the object that that name refers to, and it's difficult to talk about objects without using their names. I don't know if this makes things clearer or is just more confusing, but suppose we call the first list object1, and the second one object2 (that is, we'll pretend that if you take the id of the first object, you get 1, and if you take the id of the second one, you get 2). When you call test, you pass object1 with the name "x". If you have the line x=[2], you're creating object2, putting the value 2 in it, and telling Python that within the function test, the name x points to object2. If you have the line x[0]=2, on the other hand, you're still dealing with object1, and you're changing the value of its first element to 2.

So x[0] = 2 accessing the first element of the object and global x = 2 changes x to a new object. Thank you that was incredibly helpful and insightful. I noticed that a lot of professional programmers that do tutorials are so used to all the concepts and the syntax of python which isn't as intuitive to a beginner. — CaptainAble2500, May 30 '21 at 19:44

Mutable vs. Immutable object specifically lists

1 Answers1