What is the difference between delay variables and free_list linked lists in Python3?

1. Concept

1. Difference

In Python3, "delay variable" and "free_list linked list" are two different concepts, and there is no direct connection between them.

2. Delay variable (Lazy evaluation)

Delay variable means that in some cases, Python will not immediately calculate the value of the expression, but wait until the value is needed. while doing calculations. This approach is called "lazy evaluation" or "delayed evaluation".

For example: Generator is a method of delayed calculation.

When a generator object is created, it will not generate all the values ​​immediately, but one by one when needed. The advantage of this method is: saving memory space and computing resources

3. free_list linked list

The free_list linked list is a memory management mechanism in Python3. A garbage collection mechanism is used to automatically manage memory space. The free_list linked list is a mechanism that can reuse allocated but unused memory blocks.

When a new object is created, Python allocates a memory space and marks it as used. When an object is no longer referenced, Python automatically marks it as unused and adds it to the free_list. When an object is created next time, Python will first check whether there is a reusable memory block in the free_list linked list, thereby avoiding unnecessary memory allocation and release operations.

2. Example

1. Delay variable example

In this example, a generator function is definedfibonacci() , realizing the generation logic of Fibonacci sequence. When we create a generator object fib, it will not generate all Fibonacci sequence values ​​at once, but one by one when needed. Here, we use the next() function to get the next Fibonacci sequence value.

# 定义一个生成器，实现斐波那契数列
def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a , b = b, a+b
#创建一个生成器对象
fib = fibonacci()
#打印前 10 个斐波那契数列数值
for i in range(10):
    print(next(fib))
'''
执行结果如下：
0
1
1
2
3
5
8
13
21
34
'''

2.free_list linked list

In this example, we first create two identical list objects a and b, and print their memory address. We then remove the a object from memory and force garbage collection using gc.collect(). Next, we create a new list object c and print its memory address. Finally, we use the sys.getsizeof([]) function to check whether there are reusable memory blocks in the free_list linked list

import sys
import gc
#创建两个相同的列表对象
a = [1, 2, 3]
b = [1, 2, 3]
#打印a和b对象的内存地址
print("a 的内存地址：", id(a))
print("b 的内存地址：", id(b))
#将a 对象从内存中删除
del a
# 创建一个新的列表对象 c
# 强制进行垃圾回收
gc.collect()
c = [1, 2, 3]
#打印 c 对象的内存地址
print("c 的内存地址：", id(c))
 
#检查 free_list 链表中是否有可重复利用的内存块
print("free_list 链表：", sys.getsizeof([]))
'''
执行结果如下：
a 的内存地址： 22203400
b 的内存地址： 22201928
c 的内存地址： 21904648
free_list 链表： 64
'''

gc.collect() Garbage collection can be forced, but it does not mean that the memory will be cleared immediately. Memory management in Python is jointly managed by the interpreter and the operating system. The specific memory allocation and recycling timing are also affected by various factors, such as garbage collector algorithm, system memory usage, etc.

In the above example, when we delete the a object and call gc.collect() for garbage collection, the Python interpreter will a The memory occupied by the object is marked as recyclable and added to the garbage collector's to-be-recycled list. However, this does not mean that the memory is reclaimed immediately, but will be cleaned up during the next round of collection by the garbage collector.

In addition, even if the memory occupied by the a object is recycled, it does not necessarily mean that the memory space is released immediately, because the memory management in Python adopts a delayed allocation mechanism. , that is, Python will request the operating system to allocate new memory space only when it needs to apply for more memory. Therefore, in the above example, although the memory space of the a object may have been reclaimed, the memory space may still be reserved by the Python interpreter for future use, thereby avoiding unnecessary memory allocation and deallocation overhead .

It should be noted that even if the memory addresses of the three objects a, b, and c do not overlap, it does not mean that the memory they occupy The spaces will not overlap. This is because the memory management method in Python is allocated and managed in units of objects. The memory space occupied by each object may be discontinuous, so the memory spaces of different objects may partially overlap.

The above is the detailed content of What is the difference between delay variables and free_list linked lists in Python3?. For more information, please follow other related articles on the PHP Chinese website!