Het opzetten van een versiecontrolesysteem voor je Pandas DataFrame kan effectief worden gedaan door gebruik te maken van een versiebeheerbibliotheek zoals `dvc` (Data Version Control) of door je DataFrame op te slaan als bestanden en deze versies te beheren met Git. Hier geef ik een voorbeeld met eenvoudige bestandsopslag en Git, en enkele tips voor het afhandelen van conflicten. Stap 1: DataFrame opslaan als CSV-bestand en versies beheren ```python import pandas as pd import os import datetime # Voorbeeld DataFrame df = pd.DataFrame({ 'Product': ['A', 'B', 'C'], 'Maand': ['2024-01', '2024-02', '2024-03'], 'Verkoop': [100, 150, 200] }) # Functie om versies te bewaren def save_version(df, versie_dir='versies'): if not os.path.exists(versie_dir): os.makedirs(versie_dir) timestamp = datetime.datetime.now().strftime('%Y%m%d_%H%M%S') filename = os.path.join(versie_dir, f'versie_{timestamp}.csv') df.to_csv(filename, index=False) print(f"Versie opgeslagen: {filename}") # Een nieuwe versie opslaan save_version(df) ``` Stap 2: Versiebeheer met Git - Initialiseer een Git-repository in je projectmap: ```bash git init ``` - Voeg de map met versies toe aan je repository: ```bash git add versies/ git commit -m "Startversie van verkoopgegevens" ``` - Elke keer dat je een nieuwe wijziging doorvoert, sla je een versie op en commit je deze: ```python save_version(df) os.system('git add versies/') os.system('git commit -m "Update verkoopgegevens voor maand X"') ``` Stap 3: Terugkeren naar een eerdere versie - Gebruik Git om een specifieke versie te bekijken of terug te zetten: ```bash git checkout <commit_hash> -- versies/versie_<timestamp>.csv ``` Of door een specifieke bestandsversie te openen. Stap 4: Verschillen en samenvoegingen - Om verschillen tussen versies te vergelijken, kun je `diff` tools gebruiken, bijvoorbeeld: ```bash git diff <commit1> <commit2> -- versies/ ``` - Om nieuwe data te mergen of conflicten op te lossen, vergelijk je de CSV's handmatig of met tools zoals `diff` of `pandas` zelf: ```python # Voorbeeld: laden van twee versies en vergelijken df_latest = pd.read_csv('versies/versie_latest.csv') df_oud = pd.read_csv('versies/versie_oud.csv') # Bijvoorbeeld, verschil vinden verschil = df_latest.compare(df_oud) print(verschil) ``` **Effectief afhandelen van conflicten:** - Bij gelijktijdige wijzigingen in dezelfde rijen kan een merge conflict ontstaan. Dit kun je voorkomen door goede communicatie en door in je workflow regelmatig te committen en te pullen. - Voor complexe samenvoegingen, overweeg gebruik te maken van tools zoals `pandas` merge functies of gespecialiseerde data version control tools zoals `DVC` of `Pachyderm`. **Kort samengevat:** - Sla je DataFrame op als bestanden (bijvoorbeeld CSV) met duidelijke versienamen. - Gebruik Git om deze bestanden versie te beheren. - Voor het vergelijken en herstellen van versies, maak gebruik van Git en Pandas. - Bij conflicten, vergelijk de CSV's en los ze handmatig op of gebruik merge tools. Wil je een meer geautomatiseerd of schaalbaar systeem? Overweeg dan DVC, dat speciaal ontworpen is voor dataversionering en integratie met Git.

Hier is een uitgebreid systeem voor versiebeheer van je Pandas DataFrame met codevoorbeelden: ## Basis Versiecontrolesysteem ```python import pandas as pd import json from datetime import datetime import hashlib import os class DataFrameVersionControl: def __init__(self, base_dataframe, storage_path="version_control/"): self.storage_path = storage_path self.versions = {} self.current_version = None # Maak opslagmap aan if not os.path.exists(storage_path): os.makedirs(storage_path) # Sla initiële versie op if base_dataframe is not None: self.commit(base_dataframe, "Initial commit") def _get_dataframe_hash(self, df): """Genereer hash voor DataFrame om wijzigingen te detecteren""" return hashlib.md5(pd.util.hash_pandas_object(df).values.tobytes()).hexdigest() def commit(self, dataframe, message): """Sla nieuwe versie op""" version_id = datetime.now().strftime("%Y%m%d_%H%M%S") new_hash = self._get_dataframe_hash(dataframe) # Controleer of er wijzigingen zijn if self.current_version and new_hash == self.versions[self.current_version]['hash']: print("Geen wijzigingen gedetecteerd") return False # Sla DataFrame op filename = f"{self.storage_path}version_{version_id}.parquet" dataframe.to_parquet(filename) # Bewaar versie-info self.versions[version_id] = { 'filename': filename, 'message': message, 'timestamp': datetime.now(), 'hash': new_hash, 'shape': dataframe.shape } self.current_version = version_id print(f"Versie {version_id} opgeslagen: {message}") return True def checkout(self, version_id): """Haal specifieke versie op""" if version_id not in self.versions: raise ValueError(f"Versie {version_id} niet gevonden") df = pd.read_parquet(self.versions[version_id]['filename']) self.current_version = version_id return df def get_version_history(self): """Toon versiegeschiedenis""" history = [] for version_id, info in sorted(self.versions.items()): history.append({ 'version': version_id, 'message': info['message'], 'timestamp': info['timestamp'], 'shape': info['shape'] }) return pd.DataFrame(history) def diff(self, version_a, version_b): """Vergelijk twee versies""" df_a = self.checkout(version_a) df_b = self.checkout(version_b) differences = {} # Vergelijk shape if df_a.shape != df_b.shape: differences['shape'] = { 'version_a': df_a.shape, 'version_b': df_b.shape } # Vergelijk kolommen cols_a = set(df_a.columns) cols_b = set(df_b.columns) if cols_a != cols_b: differences['columns'] = { 'added': list(cols_b - cols_a), 'removed': list(cols_a - cols_b) } # Vergelijk waarden (vereenvoudigd) if df_a.shape == df_b.shape and set(df_a.columns) == set(df_b.columns): numeric_cols = df_a.select_dtypes(include=['number']).columns if len(numeric_cols) > 0: value_diff = (df_a[numeric_cols] != df_b[numeric_cols]).sum().sum() differences['value_changes'] = value_diff return differences ``` ## Gebruiksvoorbeeld ```python # Voorbeeld DataFrame data = { 'Product': ['A', 'B', 'C', 'D'], 'Verkoop_Jan': [100, 150, 200, 50], 'Verkoop_Feb': [120, 160, 180, 60], 'Categorie': ['Elektronica', 'Huis', 'Elektronica', 'Kantoor'] } df = pd.DataFrame(data) # Initialiseer versiecontrole vc = DataFrameVersionControl(df, "verkoop_versies/") # Maak wijzigingen en commit df_gewijzigd = df.copy() df_gewijzigd.loc[0, 'Verkoop_Feb'] = 130 vc.commit(df_gewijzigd, "Verkoop product A bijgewerkt") # Voeg nieuw product toe df_nieuw = df_gewijzigd.copy() nieuw_product = pd.DataFrame({ 'Product': ['E'], 'Verkoop_Jan': [75], 'Verkoop_Feb': [80], 'Categorie': ['Huis'] }) df_nieuw = pd.concat([df_nieuw, nieuw_product], ignore_index=True) vc.commit(df_nieuw, "Nieuw product E toegevoegd") # Toon geschiedenis print(vc.get_version_history()) # Vergelijk versies diff_result = vc.diff('20240101_120000', '20240101_120500') print("Verschillen:", diff_result) # Terugkeren naar eerdere versie oude_versie = vc.checkout('20240101_120000') print("Oude versie:", oude_versie) ``` ## Geavanceerd: Samenvoegen van Wijzigingen ```python class AdvancedDataFrameVC(DataFrameVersionControl): def merge(self, main_branch, feature_branch, merge_strategy='smart'): """Samenvoegen van verschillende versies""" df_main = self.checkout(main_branch) df_feature = self.checkout(feature_branch) if merge_strategy == 'overwrite': return df_feature.copy() elif merge_strategy == 'smart': # Slim samenvoegen op basis van gemeenschappelijke kolommen common_cols = list(set(df_main.columns) & set(df_feature.columns)) index_col = 'Product' # Veronderstel dat Product de unieke identifier is if index_col in common_cols: # Gebruik merge op basis van Product merged_df = pd.merge( df_main, df_feature, on=index_col, how='outer', suffixes=('_main', '_feature') ) # Conflict resolutie: geef voorrang aan feature branch for col in common_cols: if col != index_col: main_col = f"{col}_main" feature_col = f"{col}_feature" if main_col in merged_df.columns and feature_col in merged_df.columns: # Gebruik feature waarde als beschikbaar, anders main merged_df[col] = merged_df[feature_col].combine_first(merged_df[main_col]) # Verwijder tijdelijke kolommen cols_to_drop = [col for col in merged_df.columns if '_main' in col or '_feature' in col] merged_df = merged_df.drop(columns=cols_to_drop) return merged_df else: raise ValueError("Geen geschikte index kolom gevonden voor samenvoegen") else: raise ValueError(f"Onbekende merge strategie: {merge_strategy}") def detect_conflicts(self, version_a, version_b): """Detecteer conflicten tussen versies""" df_a = self.checkout(version_a) df_b = self.checkout(version_b) conflicts = { 'shape_conflict': df_a.shape != df_b.shape, 'column_conflicts': { 'added': list(set(df_b.columns) - set(df_a.columns)), 'removed': list(set(df_a.columns) - set(df_b.columns)) }, 'data_conflicts': {} } # Detecteer waarde conflicten voor gemeenschappelijke rijen/kolommen common_cols = list(set(df_a.columns) & set(df_b.columns)) if 'Product' in common_cols: common_products = set(df_a['Product']) & set(df_b['Product']) for product in common_products: row_a = df_a[df_a['Product'] == product].iloc[0] row_b = df_b[df_b['Product'] == product].iloc[0] for col in common_cols: if col != 'Product' and row_a[col] != row_b[col]: if product not in conflicts['data_conflicts']: conflicts['data_conflicts'][product] = {} conflicts['data_conflicts'][product][col] = { 'version_a': row_a[col], 'version_b': row_b[col] } return conflicts ``` ## Conflict Resolutie Voorbeeld ```python # Gebruik geavanceerde versiecontrole advanced_vc = AdvancedDataFrameVC(df, "advanced_versions/") # Maak twee verschillende branches df_branch_a = df.copy() df_branch_a.loc[0, 'Verkoop_Feb'] = 135 # Wijziging in branch A df_branch_b = df.copy() df_branch_b.loc[1, 'Verkoop_Jan'] = 170 # Wijziging in branch B df_branch_b['Korting'] = [0.1, 0.05, 0.2, 0.0] # Nieuwe kolom in branch B advanced_vc.commit(df_branch_a, "Branch A: Product A verkoop bijgewerkt") advanced_vc.commit(df_branch_b, "Branch B: Product B verkoop + korting kolom") # Detecteer conflicten conflicts = advanced_vc.detect_conflicts('20240101_120000', '20240101_120100') print("Gedetecteerde conflicten:", json.dumps(conflicts, indent=2, default=str)) # Samenvoegen try: merged_df = advanced_vc.merge('20240101_120000', '20240101_120100', 'smart') advanced_vc.commit(merged_df, "Samenvoeging branch A en B") print("Succesvol samengevoegd") except Exception as e: print(f"Samenvoegen mislukt: {e}") ``` ## Best Practices 1. **Regelmatig committen**: Sla belangrijke wijzigingen op 2. **Beschrijvende commit-berichten**: Leg wijzigingen duidelijk uit 3. **Versie labels gebruiken**: Gebruik betekenisvolle namen voor belangrijke versies 4. **Automatische tests**: Voeg validatie toe voor belangrijke wijzigingen 5. **Backup strategie**: Bewaar belangrijke versies extern Dit systeem geeft je een robuust framework voor het beheren van DataFrame wijzigingen in de tijd!