Questa guida delinea le migliori pratiche per scrivere codice efficiente e performante con TomatoPy.
Gestione della Memoria
Creazione Efficiente degli Ingredienti
# Buono: Crea ingredienti con un uso minimo della memoriatomato =Tomato( ripeness=0.8, variety="San Marzano", weight=150)# Cattivo: Creare copie non necessarietomato_copy = tomato.copy()# Uso di memoria non necessario
Elaborazione in Batch
# Buono: Elabora ingredienti in batchdefprocess_ingredients(ingredients,batch_size=100):for i inrange(0, len(ingredients), batch_size): batch = ingredients[i:i + batch_size]process_batch(batch)# Cattivo: Elaborazione uno alla voltafor ingredient in ingredients:process_single(ingredient)# Meno efficiente
Ottimizzazione delle Prestazioni
Caching dei Risultati
from functools import lru_cache
# Buono: Cache delle computazioni costose
@lru_cache(maxsize=128)
def analyze_ingredient(ingredient):
return TasteTester().analyze(ingredient)
# Cattivo: Ricalcolare ogni volta
def analyze_ingredient(ingredient):
return TasteTester().analyze(ingredient) # Nessun caching
Strutture Dati Efficaci
# Buono: Usa strutture dati appropriate
from collections import defaultdict
class Recipe:
def __init__(self):
self.ingredients = defaultdict(float) # Efficiente per il tracciamento degli ingredienti
# Cattivo: Uso di strutture inefficienti
class Recipe:
def __init__(self):
self.ingredients = [] # Meno efficiente per le ricerche
Gestione delle Risorse
Gestori di Contesto
# Buono: Usa gestori di contesto per la pulizia delle risorse
with kitchen.temperature_monitor() as monitor:
result = kitchen.cook(ingredient)
data = monitor.get_data()
# Cattivo: Gestione manuale delle risorse
monitor = kitchen.temperature_monitor()
try:
result = kitchen.cook(ingredient)
data = monitor.get_data()
finally:
monitor.cleanup() # Più soggetto a errori
Pooling delle Connessioni
# Buono: Usa il pooling delle connessioni
from tomatopy import ConnectionPool
pool = ConnectionPool(max_connections=10)
with pool.get_connection() as conn:
conn.execute_operation()
# Cattivo: Creare nuove connessioni ogni volta
conn = create_connection() # Meno efficiente
conn.execute_operation()
conn.close()
Ottimizzazione degli Algoritmi
Ricerca Efficiente
# Buono: Usa la ricerca binaria per dati ordinati
def find_optimal_temperature(sorted_temps, target):
left, right = 0, len(sorted_temps) - 1
while left <= right:
mid = (left + right) // 2
if sorted_temps[mid] == target:
return mid
elif sorted_temps[mid] < target:
left = mid + 1
else:
right = mid - 1
return -1
# Cattivo: Ricerca lineare
def find_optimal_temperature(temps, target):
for i, temp in enumerate(temps):
if temp == target:
return i
return -1
Elaborazione Parallela
from concurrent.futures import ThreadPoolExecutor
# Buono: Elabora più ingredienti in parallelo
def process_ingredients_parallel(ingredients):
with ThreadPoolExecutor(max_workers=4) as executor:
results = list(executor.map(process_ingredient, ingredients))
return results
# Cattivo: Elaborazione sequenziale
def process_ingredients_sequential(ingredients):
results = []
for ingredient in ingredients:
results.append(process_ingredient(ingredient))
return results
Organizzazione del Codice
Design Modulare
# Buono: Struttura del codice modulare
class IngredientProcessor:
def process(self, ingredient):
self.validate(ingredient)
self.prepare(ingredient)
self.analyze(ingredient)
# Cattivo: Funzioni monolitiche
def process_ingredient(ingredient):
# Tutto il processamento in una funzione
validate_ingredient(ingredient)
prepare_ingredient(ingredient)
analyze_ingredient(ingredient)
# Buono: Recupero dagli errori in modo elegante
def process_recipe(recipe):
try:
result = kitchen.cook_recipe(recipe)
return result
except TemperatureError:
# Gestisci l'errore di temperatura
return adjust_temperature(recipe)
except IngredientError:
# Gestisci l'errore di ingrediente
return substitute_ingredients(recipe)
finally:
cleanup_resources()
# Cattivo: Nessun recupero dagli errori
def process_recipe(recipe):
result = kitchen.cook_recipe(recipe)
return result # Nessuna gestione degli errori
Pulizia delle Risorse
# Buono: Pulizia adeguata delle risorse
classe Cucina:
def __init__(self):
self.resources = []
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.cleanup()
# Cattivo: Pulizia manuale
def use_kitchen():
kitchen = Cucina()
try:
# Usa la cucina
pass
finally:
kitchen.cleanup()
Test e Profilazione
Prossimi Passi
# Good: Performance testing
import time
import cProfile
def profile_operation(func):
def wrapper(*args, **kwargs):
profiler = cProfile.Profile()
result = profiler.runcall(func, *args, **kwargs)
profiler.print_stats()
return result
return wrapper
# Bad: No performance testing
def operation():
# No performance monitoring
pass
Memory Profiling
# Good: Memory profiling
from memory_profiler import profile
@profile
def memory_intensive_operation():
# Operation to profile
pass
# Bad: No memory profiling
def memory_intensive_operation():
# No memory monitoring
pass
