Zeker! Hieronder vind je een voorbeeld van hoe je een prestatieprofileringsscript kunt maken voor je `verwerk_data` functie in Python, inclusief gebruik van `cProfile` en `memory_profiler`. Ook geef ik uitleg over het interpreteren van de resultaten. --- ### 1. Profileringsscript met `cProfile` en `memory_profiler` **a. Vereiste pakketten installeren (indien nog niet aanwezig):** ```bash pip install memory_profiler ``` **b. Voorbeeld code** ```python import cProfile import pstats from memory_profiler import memory_usage def verwerk_data(data): resultaat = [] for item in data: resultaat.append(item ** 2) return resultaat def profile_code(): test_data = list(range(10000)) # voorbeeld data, pas aan naar behoefte # Profileren met cProfile profiler = cProfile.Profile() profiler.enable() # Profileren geheugengebruik mem_usage = memory_usage((verwerk_data, (test_data,)), interval=0.1) result = verwerk_data(test_data) profiler.disable() # Resultaten tonen print("Profilering met cProfile:") stats = pstats.Stats(profiler) stats.strip_dirs() stats.sort_stats('cumulative') stats.print_stats(10) # top 10 functies print("\nGeheugengebruik tijdens uitvoering (in MB):") print(f"Min: {min(mem_usage):.2f} MB") print(f"Max: {max(mem_usage):.2f} MB") print(f"Gemiddeld: {sum(mem_usage)/len(mem_usage):.2f} MB") if __name__ == "__main__": profile_code() ``` --- ### 2. Hoe de resultaten te interpreteren: **a. cProfile-uitvoer:** - **Totaal tijd:** De kolom `tottime` geeft de totale tijd die door de functie zelf wordt besteed. - **Cumulatieve tijd:** `cumtime` geeft de tijd inclusief alle onderliggende functies. - **Aantal oproepen:** `calls` laat zien hoe vaak functies worden aangeroepen. - **Interpretatie:** functies met hoge `cumtime` of veel oproepen kunnen bottlenecks vormen. Optimaliseer die delen eerst. **b. Memory Profiler-uitvoer:** - **Min/Max/Gemiddeld geheugengebruik:** Geeft inzicht in het geheugengebruik tijdens de uitvoering. - **Interpretatie:** grote pieken kunnen aangeven dat bepaalde delen van je code veel geheugen gebruiken. Overweeg optimalisaties zoals gebruik van generatoren of efficiëntere datastructuren. --- ### 3. Optimalisatietips: - **Vermijd onnodige lijsten:** bijvoorbeeld, gebruik generatoren waar mogelijk. - **Gebruik numpy:** voor grote numerieke gegevenssets kan numpy veel sneller en geheugen-efficiënter zijn. - **Vermijd herhaalde berekeningen:** cache resultaten indien mogelijk. - **Paralleliseer:** voor grote datasets, overweeg parallelle verwerking met `multiprocessing`. --- ### Samenvatting Door dit script te gebruiken, krijg je inzicht in de uitvoeringstijd en geheugengebruik van je `verwerk_data` functie. Aan de hand van de rapportages kun je gerichte aanpassingen maken, zoals het reduceren van herhaalde berekeningen of het verbeteren van geheugengebruik. Wil je dat ik de scripts verder aanpas of meer uitleg geef over specifieke optimalisaties?

Hier is een complete handleiding voor het maken van prestatieprofileringsscripts voor jouw Python-code met Amazon CodeWhisperer: ## 1. Basis Profileringsscript ```python import time import memory_profiler import cProfile import pstats def verwerk_data(data): resultaat = [] for item in data: resultaat.append(item ** 2) return resultaat def profileer_uitvoeringstijd(data): """Profileert de uitvoeringstijd van verwerk_data""" start_tijd = time.time() resultaat = verwerk_data(data) eind_tijd = time.time() uitvoeringstijd = eind_tijd - start_tijd print(f"Uitvoeringstijd: {uitvoeringstijd:.4f} seconden") return resultaat, uitvoeringstijd def profileer_geheugengebruik(data): """Profileert het geheugengebruik van verwerk_data""" geheugen_voor = memory_profiler.memory_usage()[0] resultaat = verwerk_data(data) geheugen_na = memory_profiler.memory_usage()[0] geheugen_verschil = geheugen_na - geheugen_voor print(f"Geheugentoename: {geheugen_verschil:.2f} MB") return resultaat, geheugen_verschil ``` ## 2. Geavanceerd Profileringsscript met cProfile ```python import cProfile import pstats import io from memory_profiler import profile @profile def verwerk_data_met_profiling(data): """Versie van verwerk_data met geheugenprofiling decorator""" resultaat = [] for item in data: resultaat.append(item ** 2) return resultaat def uitgebreide_profiling(data): """Voert uitgebreide profiling uit met cProfile""" # cProfile voor gedetailleerde prestatieanalyse profiler = cProfile.Profile() profiler.enable() resultaat = verwerk_data(data) profiler.disable() # Resultaten weergeven stream = io.StringIO() stats = pstats.Stats(profiler, stream=stream) stats.sort_stats('cumulative') stats.print_stats(10) # Top 10 functies print("cProfile Resultaten:") print(stream.getvalue()) return resultaat ``` ## 3. Complete Test en Benchmark Script ```python import time import memory_profiler import numpy as np def benchmark_verschillende_datagroottes(): """Test prestaties met verschillende datagroottes""" test_groottes = [1000, 10000, 100000, 1000000] print("Benchmark Resultaten:") print("=" * 50) for grootte in test_groottes: # Genereer testdata test_data = list(range(grootte)) print(f"\nDatagrootte: {grootte}") # Uitvoeringstijd profiling start_tijd = time.time() resultaat = verwerk_data(test_data) uitvoeringstijd = time.time() - start_tijd # Geheugen profiling geheugen_voor = memory_profiler.memory_usage()[0] resultaat = verwerk_data(test_data) geheugen_na = memory_profiler.memory_usage()[0] print(f"Uitvoeringstijd: {uitvoeringstijd:.4f}s") print(f"Geheugentoename: {geheugen_na - geheugen_voor:.2f}MB") print(f"Geheugen per element: {(geheugen_na - geheugen_voor) / grootte:.6f}MB") def geoptimaliseerde_versie(data): """Geoptimaliseerde versie met list comprehension""" return [item ** 2 for item in data] def vergelijk_optimalisaties(data): """Vergelijkt originele en geoptimaliseerde versie""" print("\nVergelijking Optimalisaties:") print("=" * 40) # Originele versie start = time.time() orig_resultaat = verwerk_data(data) orig_tijd = time.time() - start # Geoptimaliseerde versie start = time.time() opt_resultaat = geoptimaliseerde_versie(data) opt_tijd = time.time() - start print(f"Origineel: {orig_tijd:.4f}s") print(f"Geoptimaliseerd: {opt_tijd:.4f}s") print(f"Verbetering: {((orig_tijd - opt_tijd) / orig_tijd * 100):.1f}%") ``` ## 4. Hoe te Gebruiken ```python # Hoofdscript om alles uit te voeren if __name__ == "__main__": # Testdata test_data = list(range(100000)) print("Standaard Profiling:") profileer_uitvoeringstijd(test_data) profileer_geheugengebruik(test_data) print("\nUitgebreide Profiling:") uitgebreide_profiling(test_data) print("\nBenchmark:") benchmark_verschillende_datagroottes() print("\nOptimalisatie Vergelijking:") vergelijk_optimalisaties(test_data[:10000]) ``` ## Installatie Vereisten ```bash pip install memory-profiler pip install numpy # Optioneel voor grotere datasets ``` ## Interpretatie van Resultaten ### Uitvoeringstijd Analyse: - **< 0.1s**: Zeer goed - **0.1-1s**: Acceptabel - **> 1s**: Mogelijk optimalisatie nodig ### Geheugengebruik Analyse: - **Lineaire groei**: Verwacht gedrag - **Exponentiële groei**: Mogelijk geheugenlek - **Onverwacht hoog**: Onnodige data kopieën ### cProfile Resultaten Interpretatie: - **ncalls**: Aantal functie-aanroepen - **tottime**: Totale tijd in functie (exclusief sub-functies) - **cumtime**: Cumulatieve tijd (inclusief sub-functies) - **percall**: Tijd per aanroep ## Optimalisatie Tips Gebaseerd op Profiling 1. **Bij hoge uitvoeringstijd**: - Gebruik list comprehensions i.p.v. for-loops - Overweeg NumPy voor numerieke berekeningen - Vermijd onnodige functie-aanroepen in loops 2. **Bij hoog geheugengebruik**: - Gebruik generators i.p.v. lists - Verwijder ongebruikte variabelen - Gebruik `del` om grote objecten expliciet te verwijderen 3. **Voor jouw specifieke code**: ```python # Origineel (trager) def verwerk_data(data): resultaat = [] for item in data: resultaat.append(item ** 2) return resultaat # Geoptimaliseerd (sneller) def verwerk_data_opt(data): return [x**2 for x in data] ``` Deze scripts geven je een compleet beeld van de prestaties van je code en helpen bij het identificeren van optimalisatiemogelijkheden!