Explanation of Mutable objects and immutable objects in Python

Here is a small series of people to bring a brief talk about mutable objects and immutable objects in Python. Small series feel very good, now share to everyone, also for everyone to make a reference. Let's take a look at it with a little knitting.

What is a mutable/immutable object

An immutable object in which the object points to an in-memory value that cannot be changed. When a variable is changed, because the value it refers to cannot be changed, it is equivalent to copy the original value and then change, this will open a new address, the variable point to the new address.

A mutable object in which the object points to an in-memory value that can be changed. Variables (accurately referred to) after the change, is actually the value of its direct change, and did not occur replication behavior, nor open up new addresses, popular point is to change in situ.

In Python, numeric types (int and float), string str, tuple tuples are immutable types. The list, dictionary dict, and set set are mutable types.

Or see the code more intuitive. See Non-mutable objects first

Examples of immutable objects

The first point is to determine whether the ID of two objects is the same, and = = Determines whether the content is the same.

A = 2b = 2c = A + 0 c + = 0print (ID (a), id (b), ID (2)) # The IDs are all the same print (c is b) #True

Look again at the string

Astr = ' good ' BSTR = ' good ' CStr = Astr + ' Print (CStr is BSTR) # Trueprint (ID (ASTR), ID (BSTR), ID (' good ')) # three ID same

Is the same as the result of a numeric type. If this is the case, the variable is not good after it is modified

Astr = ' good ' Print (ID (astr)) astr + = ' AA ' Print (ID (ASTR)) # ID is not the same as above

Because it is an immutable object, the value of the variable corresponding to the memory is not allowed to be changed. When the variable to change, in fact, the original value is copied a copy and then change, open a new address, astr again point to the new address (so the ID of the front and back astr is not the same), the original astr corresponding value because no longer have the object point to it, it will be garbage collection. This is the same for int and float types.

Look at the tuple again.

Add = (1, 2, 3) Aee = (1, 2, 3) print (ID (add), ID (AEE), id ((1, 2, 3)) # ids are different AEE = (1, 2, 3) print (ID (AEE)) Aee + = () # Add empty tuple Print (ID (AEE)) # ID changed! Print (AEE) # (1, 2, 3)

Although it all seems to be (1, 2, 3) it should be consistent with the above. Is this a mutable object? Look again

Add = (1, 2, 3) AEE = add print (ID (AEE), id (add)) # These two IDs are the same AEE + = (4, 5, 6) Print (ID (AEE)) # AEE ID changed! Print (add) # Add or (1, 2, 3) does not change

And the value type is the same as the STR type. If the variable object is add = Aee, they point to the same address (the same ID) is positive. But not a different reference to the same object, because if so, the change of AEE will cause the change of add, which is not the case in the tuple. So a tuple is an immutable object, but a little bit different from STR and numeric types. The commonly said tuple can not be changed many times refers to the stored value can not be changed (some special cases, such as a tuple inside the list, can change the elements in the list.) But in fact the tuple has not been changed).

For str, int, float as long as they are again the same type, the values are the same, then their IDs are the same. (Why would you say the same type?) ）

A = 2.0b = 2print (A is B) # False, an int is a float and the types are different

2 and 2.0 are not on one address.

Examples of mutable objects

Lis = [1, 2, 3]lis2 = [1, 2, 3]# although their contents are the same, but they point to different memory addresses print (LIS is Lis2) print (ID (LIS), ID (LIS2), id ([1, 2, 3]) # three IDs are different

And then look at the assignment.

Alist = [1, 2, 3]# alist is actually a reference to an object, blist = Alist is the passing of the reference, and now two references point to the same object (address) blist = Alistprint (ID (alist), ID (blist)) # ID # So one of the changes that will affect another blist.append (4) print (alist) # changes blist, Alist also becomes [1, 2, 3 4]print (ID (alist), ID (blist)) # ID, The same as the ID when the face value hasn't changed.

Blist = alist this sentence. Alist is actually a reference to the object, blist = Alist is the passing of the reference, and now all two references point to the same object (address). So one of the changes will affect the other

And look at set.

ABB = {1, 2, 3}ACC = Abbprint (ID (ABB), ID (ACC)) Acc.add (4) print (ABB) # {1, 2, 3, 4} print (ID (ABB), ID (ACC)) # Equal

It is consistent with the example above list.

Mutable objects because the object can be modified, so there is no need to duplicate a copy and then change, directly in situ changes, so will not open up new memory, change the ID and the same.

Of course the immutable object is not like this, can compare with this

ABC = 3DD = ABCDD = 43print (ABC) # 3, does not change with DD

But if it is a copy, it is simply copying the contents of the past, passing it and not referencing it. This is especially useful when you want to use the values of the list and don't want to modify the original list.

Blist = alist[:] # or Alist.copy () print (Alist is blist) # falseblist.append (4) print (alist) # or [3] no change

As a function parameter

As a function parameter, it is the same, the mutable type passes a reference, and the immutable type passes the content.

Test_list = [1, 2, 3, 4]test_str = ' HAHA ' def Change (alist):  alist.append (5) def not_change (astr):  astr.lower () Change (test_list) not_change (test_str) print (test_list) # changed the original value print (TEST_STR) # did not change

Of course, if you don't want to change the value of the original list, the parameter can pass in the column's copy. alsit[:]

An interesting example

Looking at an interesting example, we know that list can be added using +.

a1 = [1, 2, 3]A2 = A1print (ID (A1), ID (A2)) # is actually A2 pointing to the new object, the ID has changed. # so now A2, A1 is not the same object of two references, A2 change A1 will not change a2 = a2 + [4] # in this equation, the right of the A2 is the same as the A1 ID, once the assignment succeeds, A2 points to the new object print (ID (1), ID (A2)) # Range, A2 's ID has changed print (A1) # [1, 2, 3] has not changed

If this is the case

a1 = [1, 2, 3]A2 = A1print (ID (A1), ID (A2)) a2 + = [4] # is equivalent to calling A2.extend ([4]), where there is no new object producing print (ID (1), ID (A2)) # Equals, A2 ID not changed Print (A1)

The difference is that a2 + = [4], which is equivalent to calling A2.extend ([4]) corresponds to a change in place, and no new object is generated.