Quelle est la différence entre les variables de retard et les listes chaînées free_list en Python3 ?

1. Concept

1. Différence

En Python3, "delay variable" et "free_list linked list" sont deux concepts différents, et il n'y a pas de lien direct entre eux.

2. Évaluation paresseuse

Une variable paresseuse signifie que dans certains cas, Python ne calculera pas la valeur de l'expression immédiatement, mais attendra que la valeur soit nécessaire. Cette approche est appelée « évaluation paresseuse » ou « évaluation différée ».

Par exemple : le générateur est une méthode de calcul différé.

Lorsqu'un objet générateur est créé, il ne générera pas toutes les valeurs immédiatement, mais une par une en cas de besoin. L'avantage de cette méthode est : économiser de l'espace mémoire et des ressources informatiques

3. free_list La liste chaînée est un mécanisme de gestion de mémoire en Python3. Un mécanisme de garbage collection est utilisé pour gérer automatiquement l'espace mémoire. La liste chaînée free_list est un mécanisme qui peut réutiliser les blocs de mémoire alloués mais inutilisés.

Lorsqu'un nouvel objet est créé, Python alloue un espace mémoire et le marque comme utilisé. Lorsqu'un objet n'est plus référencé, Python le marque automatiquement comme inutilisé et l'ajoute à la free_list. Lorsqu'un objet sera créé la prochaine fois, Python vérifiera d'abord s'il existe un bloc de mémoire réutilisable dans la liste chaînée free_list, évitant ainsi les opérations inutiles d'allocation de mémoire et de libération.

2. Exemple

1. Exemple de variable de retard

Dans cet exemple, une fonction génératrice fibonacci() est définie pour implémenter la logique de génération de la séquence de Fibonacci. Lorsque nous créons un objet générateur fib, il ne générera pas toutes les valeurs de la séquence de Fibonacci en même temps, mais une par une en cas de besoin. Ici, nous utilisons la fonction next() pour obtenir la prochaine valeur de la séquence de Fibonacci.

# 定义一个生成器，实现斐波那契数列
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 listfibonacci()，实现了斐波那契数列的生成逻辑。当我们创建一个生成器对象 fib 时，它不会立即生成所有的斐波那契数列数值，而是在需要时逐个生成。在这里，我们使用了 next() 函数来获取下一个斐波那契数列数值。

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
'''

2.free_list链表

        在这个示例中，我们先创建了两个相同的列表对象 a 和 b，并打印它们的内存地址。然后，我们将 a 对象从内存中删除，并使用 gc.collect() 强制进行垃圾回收。接着，我们创建了一个新的列表对象 c，并打印它的内存地址。最后，我们使用 sys.getsizeof([]) 函数检查 free_list 链表中是否有可重复利用的内存块

rrreee

    gc.collect() 可以强制进行垃圾回收，但并不意味着内存会立即被清空。Python 中的内存管理是由解释器和操作系统共同管理的，具体的内存分配和回收时机也受到多种因素的影响，如垃圾回收器算法、系统内存使用情况等。

     在上面的示例中，当我们删除 a 对象并调用 gc.collect() 进行垃圾回收时，Python 解释器会将 a 对象所占用的内存标记为可回收状态，并将其添加到垃圾回收器的待回收列表中。但是，这并不意味着内存立即被回收，而是在垃圾回收器的下一轮回收时才会被清理。

      另外，即使 a 对象所占用的内存被回收了，也不一定意味着该内存空间被立即释放，因为 Python 中的内存管理采用了一种延迟分配的机制，即只有当需要申请更多内存时，Python 才会向操作系统请求分配新的内存空间。因此，在上面的示例中，虽然 a 对象的内存空间可能已经被回收，但该内存空间可能仍然被 Python 解释器保留以供未来使用，从而避免不必要的内存分配和释放开销。

        需要注意的是，即使 a、b、c

Dans cet exemple, nous créons d'abord deux objets de liste identiques a et b et imprimons leurs adresses mémoire. Nous supprimons ensuite l'objet a de la mémoire et forçons le garbage collection en utilisant gc.collect(). Ensuite, nous créons un nouvel objet liste c et imprimons son adresse mémoire. Enfin, nous utilisons la fonction sys.getsizeof([]) pour vérifier s'il existe des blocs de mémoire réutilisables dans la liste free_list

rrreee🎜🎜 gc.collect() peut être Le garbage collection forcé ne signifie pas que la mémoire sera effacée immédiatement. La gestion de la mémoire en Python est gérée conjointement par l'interpréteur et le système d'exploitation. L'allocation spécifique de la mémoire et le calendrier de recyclage sont également affectés par divers facteurs, tels que l'algorithme du garbage collector, l'utilisation de la mémoire système, etc. 🎜🎜 Dans l'exemple ci-dessus, lorsque nous supprimons l'objet a et appelons gc.collect() pour le garbage collection, l'interpréteur Python codera> La mémoire occupée par l'objet est marqué comme recyclable et ajouté à la liste des déchets à recycler du éboueur. Cependant, cela ne signifie pas que la mémoire est récupérée immédiatement, mais qu'elle sera nettoyée lors du prochain cycle de collecte par le ramasse-miettes. 🎜🎜 De plus, même si la mémoire occupée par l'objet a est recyclée, cela ne signifie pas forcément que l'espace mémoire est libéré immédiatement, car la gestion de la mémoire en Python adopte un mécanisme d'allocation différée, qui c'est-à-dire que ce n'est que lorsque plus de mémoire doit être demandée que Python demandera au système d'exploitation d'allouer un nouvel espace mémoire. Par conséquent, dans l'exemple ci-dessus, même si l'espace mémoire de l'objet a a pu être récupéré, l'espace mémoire peut toujours être réservé par l'interpréteur Python pour une utilisation future, évitant ainsi une allocation de mémoire inutile et une surcharge de libération. . 🎜🎜 Il est à noter que même si les adresses mémoire des trois objets a, b et c ne se chevauchent pas, cela ne signifient qu'ils occupent Les espaces mémoire ne se chevaucheront pas. En effet, la méthode de gestion de la mémoire en Python est allouée et gérée en unités d'objets. L'espace mémoire occupé par chaque objet peut être discontinu, de sorte que les espaces mémoire des différents objets peuvent se chevaucher partiellement. 🎜🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!