Was ist der Unterschied zwischen Verzögerungsvariablen und verknüpften Free_list-Listen in Python3?

1. Konzept

1. Unterschied

In Python3 sind „Verzögerungsvariable“ und „Free_list-verknüpfte Liste“ zwei verschiedene Konzepte, und es gibt keinen direkten Zusammenhang zwischen ihnen.

2. Lazy-Auswertung

Lazy-Variable bedeutet, dass Python in einigen Fällen den Wert des Ausdrucks nicht sofort berechnet, sondern wartet, bis der Wert benötigt wird. Dieser Ansatz wird „Lazy Evaluation“ oder „Delayed Evaluation“ genannt.

Zum Beispiel: Generator ist eine Methode zur verzögerten Berechnung.

Wenn ein Generatorobjekt erstellt wird, werden nicht alle Werte sofort generiert, sondern bei Bedarf einzeln. Der Vorteil dieser Methode besteht darin, Speicherplatz und Rechenressourcen zu sparen

3 free_list Die verknüpfte Liste ist ein Speicherverwaltungsmechanismus in Python3. Zur automatischen Verwaltung des Speicherplatzes wird ein Garbage-Collection-Mechanismus verwendet. Die verknüpfte Liste free_list ist ein Mechanismus, der zugewiesene, aber nicht verwendete Speicherblöcke wiederverwenden kann.

Wenn ein neues Objekt erstellt wird, weist Python einen Speicherplatz zu und markiert ihn als verwendet. Wenn auf ein Objekt nicht mehr verwiesen wird, markiert Python es automatisch als unbenutzt und fügt es der free_list hinzu. Wenn ein Objekt das nächste Mal erstellt wird, prüft Python zunächst, ob in der verknüpften Liste free_list ein wiederverwendbarer Speicherblock vorhanden ist, wodurch unnötige Speicherzuweisungs- und Freigabevorgänge vermieden werden.

2. Beispiel

1. Beispiel für eine Verzögerungsvariable

In diesem Beispiel wird eine Generatorfunktion fibonacci() definiert, um die Generierungslogik der Fibonacci-Sequenz zu implementieren. Wenn wir ein Generatorobjekt fib erstellen, generiert es nicht alle Fibonacci-Sequenzwerte auf einmal, sondern bei Bedarf einen nach dem anderen. Hier verwenden wir die Funktion next(), um den nächsten Fibonacci-Sequenzwert zu erhalten.

# 定义一个生成器，实现斐波那契数列
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 verknüpfte Listefibonacci()，实现了斐波那契数列的生成逻辑。当我们创建一个生成器对象 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

In diesem Beispiel erstellen wir zunächst zwei identische Listenobjekte a und b und drucken ihre Speicheradressen aus. Anschließend entfernen wir das a-Objekt aus dem Speicher und erzwingen die Speicherbereinigung mit gc.collect(). Als nächstes erstellen wir ein neues Listenobjekt c und geben seine Speicheradresse aus. Abschließend prüfen wir mit der Funktion sys.getsizeof([]), ob in der free_list-Liste wiederverwendbare Speicherblöcke vorhanden sind

rrreee🎜🎜 gc.collect() Die erzwungene Garbage Collection bedeutet nicht, dass der Speicher sofort gelöscht wird. Die Speicherverwaltung in Python wird gemeinsam vom Interpreter und dem Betriebssystem verwaltet. Die spezifische Speicherzuweisung und das Recycling-Timing werden auch von verschiedenen Faktoren beeinflusst, wie z. B. dem Garbage-Collector-Algorithmus, der Systemspeichernutzung usw. 🎜🎜 Wenn wir im obigen Beispiel das Objekt a löschen und gc.collect() für die Speicherbereinigung aufrufen, codiert der Python-Interpreter den vom Objekt belegten Speicher wird als recycelbar markiert und zur Liste der zu recycelnden Dateien des Garbage Collectors hinzugefügt. Dies bedeutet jedoch nicht, dass der Speicher sofort zurückgefordert wird, sondern dass er bei der nächsten Sammlungsrunde durch den Garbage Collector bereinigt wird. 🎜🎜 Selbst wenn der vom a-Objekt belegte Speicher recycelt wird, bedeutet dies nicht unbedingt, dass der Speicherplatz sofort freigegeben wird, da die Speicherverwaltung in Python einen Mechanismus zur verzögerten Zuweisung verwendet ist, Nur wenn mehr Speicher angefordert werden muss, fordert Python das Betriebssystem auf, neuen Speicherplatz zuzuweisen. Obwohl im obigen Beispiel der Speicherplatz des a-Objekts möglicherweise zurückgefordert wurde, kann der Speicherplatz dennoch vom Python-Interpreter für die zukünftige Verwendung reserviert werden, wodurch unnötige Speicherzuweisung und Release-Overhead vermieden werden . 🎜🎜 Es ist zu beachten, dass dies auch dann nicht der Fall ist, wenn sich die Speicheradressen der drei Objekte a, b und c nicht überschneiden bedeutet, dass sie die Speicherplätze belegen, die sich nicht überlappen. Dies liegt daran, dass die Speicherverwaltungsmethode in Python in Einheiten von Objekten zugewiesen und verwaltet wird. Der von jedem Objekt belegte Speicherplatz kann diskontinuierlich sein, sodass sich die Speicherplätze verschiedener Objekte teilweise überlappen können. 🎜🎜

Das obige ist der detaillierte Inhalt vonWas ist der Unterschied zwischen Verzögerungsvariablen und verknüpften Free_list-Listen in Python3?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!