Ik help je graag met cachingstrategieën voor Pandas DataFrames. Hier zijn verschillende benaderingen met codevoorbeelden: ## 1. Eenvoudige functie caching met `lru_cache` ```python from functools import lru_cache import pandas as pd import hashlib @lru_cache(maxsize=128) def cached_calculation(df_hash, column_name): """Gecachte berekening gebaseerd op DataFrame hash""" # Hier zou je je eigen berekeningen implementeren return df[column_name].mean() # Hash genereren voor DataFrame def get_dataframe_hash(df): return hashlib.md5(pd.util.hash_pandas_object(df).values.tobytes()).hexdigest() # Gebruik df_hash = get_dataframe_hash(df) result = cached_calculation(df_hash, 'jouw_kolom') ``` ## 2. Cache klasse voor DataFrame-bewerkingen ```python import pickle import os from pathlib import Path class DataFrameCache: def __init__(self, cache_dir='.cache'): self.cache_dir = Path(cache_dir) self.cache_dir.mkdir(exist_ok=True) def get_cache_key(self, operation_name, *args): """Genereer unieke cache key""" key_str = f"{operation_name}_{'_'.join(str(arg) for arg in args)}" return hashlib.md5(key_str.encode()).hexdigest() def get_cached_result(self, key): """Haal gecacht resultaat op""" cache_file = self.cache_dir / f"{key}.pkl" if cache_file.exists(): with open(cache_file, 'rb') as f: return pickle.load(f) return None def cache_result(self, key, result): """Sla resultaat op in cache""" cache_file = self.cache_dir / f"{key}.pkl" with open(cache_file, 'wb') as f: pickle.dump(result, f) def invalidate_cache(self, key=None): """Cache invalidatie""" if key: cache_file = self.cache_dir / f"{key}.pkl" if cache_file.exists(): cache_file.unlink() else: # Verwijder alle cache files for file in self.cache_dir.glob("*.pkl"): file.unlink() # Gebruik cache = DataFrameCache() def cached_groupby(df, group_column, agg_column): key = cache.get_cache_key('groupby', group_column, agg_column) cached = cache.get_cached_result(key) if cached is not None: return cached # Bereken resultaat result = df.groupby(group_column)[agg_column].mean() # Cache resultaat cache.cache_result(key, result) return result # Cache invalidatie bij data wijzigingen def on_data_change(df): cache.invalidate_cache() # Verwijder alle cache # OF: specifieke cache keys invalidaten ``` ## 3. Real-time caching met DataFrame monitoring ```python class SmartDataFrameCache: def __init__(self): self.cache = {} self.dataframe_versions = {} def track_dataframe(self, df, name): """Volg een DataFrame voor veranderingen""" self.dataframe_versions[name] = { 'hash': self._hash_dataframe(df), 'shape': df.shape } def _hash_dataframe(self, df): """Genereer hash voor DataFrame""" return hashlib.md5(pd.util.hash_pandas_object(df).values.tobytes()).hexdigest() def is_dataframe_changed(self, df, name): """Controleer of DataFrame is veranderd""" if name not in self.dataframe_versions: return True current_hash = self._hash_dataframe(df) return current_hash != self.dataframe_versions[name]['hash'] def get_cached(self, operation, df_name, *args): """Haal gecachte waarde op""" key = self._generate_key(operation, df_name, *args) return self.cache.get(key) def set_cached(self, operation, df_name, value, *args): """Sla waarde op in cache""" key = self._generate_key(operation, df_name, *args) self.cache[key] = value def _generate_key(self, operation, df_name, *args): return f"{operation}_{df_name}_{'_'.join(str(arg) for arg in args)}" def invalidate_dependent_cache(self, df_name): """Invalidate cache voor specifieke DataFrame""" keys_to_remove = [k for k in self.cache.keys() if k.startswith(f"_{df_name}_")] for key in keys_to_remove: del self.cache[key] # Gebruik smart_cache = SmartDataFrameCache() smart_cache.track_dataframe(df, 'mijn_dataframe') def get_cached_calculation(df, column): if smart_cache.is_dataframe_changed(df, 'mijn_dataframe'): smart_cache.invalidate_dependent_cache('mijn_dataframe') smart_cache.track_dataframe(df, 'mijn_dataframe') cached = smart_cache.get_cached('mean', 'mijn_dataframe', column) if cached is not None: return cached result = df[column].mean() smart_cache.set_cached('mean', 'mijn_dataframe', result, column) return result ``` ## 4. Best Practices en integratie ```python # Decorator voor automatische caching def cache_dataframe_operation(func): def wrapper(df, *args, **kwargs): # Genereer cache key gebaseerd op functienaam en arguments cache_key = f"{func.__name__}_{hashlib.md5(str(args).encode() + str(kwargs).encode()).hexdigest()}" # Controleer cache if hasattr(df, '_cache') and cache_key in df._cache: return df._cache[cache_key] # Voer functie uit result = func(df, *args, **kwargs) # Initialiseer cache indien nodig if not hasattr(df, '_cache'): df._cache = {} # Sla resultaat op df._cache[cache_key] = result return result return wrapper # Gebruik de decorator @cache_dataframe_operation def calculate_complex_metric(df, column): # Complexe berekening return df[column].rolling(window=10).mean().std() # Cache management functies def clear_dataframe_cache(df): """Wis alle cache voor een DataFrame""" if hasattr(df, '_cache'): df._cache.clear() def get_cache_info(df): """Toon cache informatie""" if hasattr(df, '_cache'): return f"Cache grootte: {len(df._cache)} items" return "Geen cache gevonden" ``` ## 5. Cache strategie voor veelgebruikte bewerkingen ```python class CommonOperationsCache: def __init__(self): self.cache = {} def cached_groupby(self, df, group_col, agg_col, operation='mean'): key = f"groupby_{group_col}_{agg_col}_{operation}" if key in self.cache and self._is_cache_valid(df, key): return self.cache[key] if operation == 'mean': result = df.groupby(group_col)[agg_col].mean() elif operation == 'sum': result = df.groupby(group_col)[agg_col].sum() elif operation == 'count': result = df.groupby(group_col)[agg_col].count() self.cache[key] = result self._store_dataframe_hash(df, key) return result def _is_cache_valid(self, df, key): """Controleer of cache nog geldig is""" current_hash = self._hash_dataframe(df) stored_hash = self.cache.get(f"{key}_hash") return stored_hash == current_hash def _store_dataframe_hash(self, df, key): """Sla DataFrame hash op voor validatie""" self.cache[f"{key}_hash"] = self._hash_dataframe(df) def _hash_dataframe(self, df): return hashlib.md5(pd.util.hash_pandas_object(df).values.tobytes()).hexdigest() def invalidate_all(self): """Wis alle cache""" self.cache.clear() # Gebruik op_cache = CommonOperationsCache() result = op_cache.cached_groupby(df, 'categorie', 'waarde', 'mean') ``` ## Belangrijke overwegingen: 1. **Cache grootte**: Beperk de cache grootte om geheugengebruik te controleren 2. **Hash methoden**: Gebruik efficiënte hashing voor grote DataFrames 3. **Invalidatie**: Zorg voor duidelijke invalidatiestrategieën bij datawijzigingen 4. **Persistentie**: Overweeg disk-caching voor zeer grote datasets 5. **Monitoring**: Houd cache hit/miss ratios bij voor optimalisatie Kies de strategie die het beste past bij jouw use case en dataverwerkingspatronen!