Shulou(Shulou.com)06/03 Report--

This article mainly introduces the example analysis of variable objects and immutable objects in python, which has certain reference value. Interested friends can refer to it. I hope you will gain a lot after reading this article. Let Xiaobian take you to understand it together.

When writing python programs, there is a lack of understanding of mutable objects and immutable objects, resulting in some detailed errors. Take the following example:

ab = {'a':1, 'b':2}list1 = []for i in range(2,5): ab['a'] = i list1.append(ab)print(list1) # [{'a': 4, 'b': 2}, {'a': 4, 'b': 2}, {'a': 4, 'b': 2}]

This code expects the result to be [{'a': 2, ' b': 2}, {'a': 3, ' b': 2}, {'a': 4, ' b': 2}], but in each dictionary in the list the value of key a becomes the last value of 4. This involves knowledge of mutable and immutable objects in python.

First of all, what is an object?

In Python, everything is an object, and objects must have three attributes: address, type, and value.

When a=5, it is a process of creation and reference. First create an object 5, 5 is stored in memory, has its own separate address space, and then a points to (references) 5.

Mutable and immutable objects

When the value of the object changes, but the memory address does not change, it is a mutable type.

When the value of the object changes and the memory address changes, it is an immutable type.

As we all know, Python variable objects are: lists, dictionaries, sets

Immutable objects include tuples, strings, and values.

The following code better explains mutable versus immutable objects:

Python refers to an immutable object, it will look for whether the object has been created, if the object has been created, the variable will directly reference the object, will not apply for new memory space.

a = 5b = 5 #In this case, both a and b refer to object 5, so the address is the same print(id(a), id(b)) # 1662825664 1662825664 #object changed, a changed reference, address also changed a = 6print(id(a), id(b)) # 1662825696 1662825664

When a mutable object is referenced, a new memory address is created, and when the mutable object value changes, the original memory address does not change

list1 = [1,2,3,4]list2 = [1,2,3,4]print(id(list1), id(list2)) #1754039591880 1754040417288list1.append(5)print(id(list1), id(list2)) #1754039591880 1754040417288

Note: If list2 = list1, the addresses of list1 and list2 will be the same. It's just a different name.

list1 = [1,2,3,4]list2 = list1print(id(list1), id(list2)) #2272617112520 2272617112520list1.append(5)print(id(list1), id(list2)) # 2272617112520 2272617112520

So why is a list mutable and a string or numeric immutable? This delves into the underlying implementation of Python data types.

List Bottom

List stores list elements by referencing arrays

Simply put, a contiguous address space is created in the list to store the addresses of reference elements. So the list stores addresses, not specific values.

dictionary bottom layer

Storage and access of values through sparse arrays

1. The process of dictionary creation

Create a hash table (sparse array, dynamically expandable)

Compute the hash value of a key by hash()

Determine its position in the hash table based on the calculated hash value

Store a value at this location

2. Dictionary access process

Computes the hash value of the key to access

According to the calculated hash value, according to certain rules, determine its position in the hash table

Read the value stored at this location

string base

Storage of Character Strings by Compact Arrays

String data is stored continuously in memory, and space utilization is high. Therefore, strings are immutable types.

The reason is that the size of each character is fixed, so the size of a string is fixed, and a fixed-size space can be allocated to the string.

Some additional information about the way function parameters are transferred

value is passed

When the parameters passed by the main function to the calling function are immutable types, only copies of the arguments (i.e. temporary copies) are actually passed to the called function, not the arguments themselves, so that the called function cannot directly modify the values of the variables in the main function, but only the values of its private temporary copies.

reference passing

When the arguments passed by the main function to the calling function are mutable types, they are actually passing references to arguments into the calling function, and operating on references is equivalent to operating on the objects specified by them.

Note the following two situations:

list1 = [1,2,3,4]def solution(list1): list1 = [1,2,3,4,5] return list1solution(list1)print(list1) # [1,2,3,4]list1 = [1,2,3,4]def solution(list1): list1.append(5) return list1solution(list1)print(list1) # [1,2,3,4,5]

The first type, using "=" inside the function, is actually equivalent to recreating a piece of memory to store a new object, pointing list1 to the new object, so it does not change list1 in the global

The second is append, which changes the value of the original object, so it is still an operation on the original object.

Thank you for reading this article carefully. I hope that the article "Example Analysis of Variable Objects and Immutable Objects in Python" shared by Xiaobian will be helpful to everyone. At the same time, I hope that everyone will support you a lot and pay attention to the industry information channel. More relevant knowledge is waiting for you to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.