Die Visualisierung der Speichernutzung mit und ohne Verwendung von Generatoren kann helfen, die Effizienzvorteile zu verstehen. Nachfolgend finden Sie einen Vergleich der Speichernutzung in zwei Szenarien:

1. Ohne Verwendung von Generatoren (alle Daten werden gleichzeitig in den Speicher geladen).
2. Verwendung von Generatoren (Laden eines Elements nach dem anderen).

Szenario 1: Ohne Generatoren

Angenommen, wir haben eine einfache Funktion, die ein Array von Zahlen von 0 bis 999.999 zurückgibt. Diese Funktion lädt alle Daten auf einmal in den Speicher.

Speichernutzung (ohne Generatoren)

Wenn die Funktion getNumbersArray aufgerufen wird:

• Anfangsspeicher: Niedrig, nur die Funktions- und Umgebungseinstellungen sind im Speicher.
• Während der Ausführung: Während die Schleife ausgeführt wird, erhöht sich die Speichernutzung linear und hält alle 1.000.000 Zahlen in einem Array.
• Spitzenspeicher: Sehr hoch, alle Daten werden gleichzeitig im Speicher gehalten.
• Nach der Ausführung: Der Speicher bleibt hoch, bis das Skript endet oder das Array explizit aufgehoben wird.

|            Memory Usage Without Generators           |
|------------------------------------------------------|
| Start    | *                                         |
|          | **                                        |
|          | ***                                       |
|          | ****                                      |
|          | *****                                     |
|          | ******                                    |
|          | *******                                   |
| ...      | ******************************************|
| End      | ******************************************|
|------------------------------------------------------|

Szenario 2: Verwendung von Generatoren

Jetzt verwenden wir eine Generatorfunktion, um eine Zahl nach der anderen zu erhalten.

Speichernutzung (mit Generatoren)

Wenn die Generatorfunktion numberGenerator aufgerufen wird:

• Anfangsspeicher: Niedrig, nur die Funktions- und Umgebungseinstellungen sind im Speicher.
• Während der Ausführung: Die Speichernutzung bleibt gering, da jeweils nur eine Zahl im Speicher gehalten wird.
• Spitzenspeicher: Niedrig, nur ein Element plus Overhead für den Generator.
• Nach der Ausführung: Die Speichernutzung sinkt sofort nach Ende der Iteration.

|            Memory Usage With Generators              |
|------------------------------------------------------|
| Start    | *                                         |
|          | *                                         |
|          | *                                         |
|          | *                                         |
|          | *                                         |
|          | *                                         |
|          | *                                         |
| ...      | *                                         |
| End      | *                                         |
|------------------------------------------------------|

Zusammenfassung

• Ohne Generatoren: Die Speichernutzung steigt mit der Größe des Datensatzes und bleibt während der gesamten Skriptausführung hoch.
• Mit Generatoren: Die Speichernutzung bleibt unabhängig von der Datensatzgröße konstant und gering, da jeweils nur ein Element verarbeitet wird.

Generatoren bieten erhebliche Vorteile bei der Speichereffizienz, insbesondere bei großen Datensätzen, indem sie jeweils ein Element liefern und während der gesamten Skriptausführung eine geringe Speichernutzung aufrechterhalten.