Natuurlijk! Hier is een Python-script dat je kan gebruiken om je DataFrame te reinigen en voor te bereiden voor analyse. Het script bevat de volgende stappen: 1. Detectie en correctie van afwijkende waarden (outliers). 2. Standaardisering van tekstkolommen. 3. Uniformering van datatypes. 4. Automatisering en herbruikbaarheid voor soortgelijke datasets. ```python import pandas as pd import numpy as np from scipy import stats # Functie om outliers te detecteren en te corrigeren met z-score def corrigeer_outliers(df, kolom, z_threshold=3): z_scores = np.abs(stats.zscore(df[kolom].dropna())) outliers = np.where(z_scores > z_threshold) # Vervang outliers door NaN of de median median = df[kolom].median() df.loc[outliers, kolom] = median return df # Functie om tekstkolommen te standaardiseren def standaardiseer_tekst(df, kolom): df[kolom] = df[kolom].astype(str).str.strip().str.lower() # Optioneel: verwijder speciale tekens, accenten, etc. # Bijvoorbeeld, met unicodedata import unicodedata df[kolom] = df[kolom].apply(lambda x: ''.join( c for c in unicodedata.normalize('NFKD', x) if not unicodedata.combining(c) )) return df # Functie om datatypes te uniformeren def uniformeer_datatypes(df): df['Leeftijd'] = pd.to_numeric(df['Leeftijd'], errors='coerce') df['Inkomensgegevens'] = pd.to_numeric(df['Inkomensgegevens'], errors='coerce') return df # Algemene reinigingsworkflow def reinig_data(df): # 1. Datatype uniformeren df = uniformeer_datatypes(df) # 2. Tekstkolommen standaardiseren for kolom in ['Naam', 'Opmerkingen']: df = standaardiseer_tekst(df, kolom) # 3. Outliers detecteren en corrigeren df = corrigeer_outliers(df, 'Leeftijd') df = corrigeer_outliers(df, 'Inkomensgegevens') # 4. Missende waarden opvullen of verwijderen df['Naam'].fillna('onbekend', inplace=True) df['Opmerkingen'].fillna('', inplace=True) df['Leeftijd'].fillna(df['Leeftijd'].median(), inplace=True) df['Inkomensgegevens'].fillna(df['Inkomensgegevens'].median(), inplace=True) return df # Voorbeeld gebruik # df = pd.read_csv('jouw_data.csv') # df_clean = reinig_data(df) # df_clean.to_csv('jouw_data_schoon.csv', index=False) ``` **Hoe automatiseer en hergebruik je deze workflow?** - **Modulariseren:** Gebruik functies voor elke stap zodat je ze gemakkelijk kunt aanpassen of uitbreiden. - **Parameterisatie:** Bied opties (bijvoorbeeld z-score drempel) als parameters aan functies. - **Script integratie:** Plaats het script in een Python-bestand en voer het uit met je dataset als input. - **Pipeline gebruik:** Maak een pipeline met bijvoorbeeld sklearn's `Pipeline` of andere workflowtools voor meer geavanceerde automatisering. - **Batchverwerking:** Loop over meerdere bestanden met een script dat automatisch alle datasets reinigt volgens dezelfde stappen. Door deze aanpak te volgen, wordt je data cleaning consistent, herhaalbaar en makkelijk aanpasbaar voor verschillende datasets.

Zeker! Ik help je met een geautomatiseerd Python-script voor geavanceerde data cleaning. Hier is een complete oplossing: ```python import pandas as pd import numpy as np import re from scipy import stats import logging class DataCleaner: def __init__(self): self.logger = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) def clean_dataframe(self, df): """Hoofdfunctie voor het reinigen van de DataFrame""" try: # Stap 1: Basisinspectie self._log_data_info(df) # Stap 2: Datatype uniformering df = self._uniform_datatypes(df) # Stap 3: Tekstkolommen standaardiseren df = self._clean_text_columns(df) # Stap 4: Ontbrekende waarden afhandelen df = self._handle_missing_values(df) # Stap 5: Uitschieters detecteren en corrigeren df = self._handle_outliers(df) # Stap 6: Finale validatie self._validate_clean_data(df) return df except Exception as e: self.logger.error(f"Fout tijdens data cleaning: {str(e)}") raise def _log_data_info(self, df): """Logt basisinformatie over de dataset""" self.logger.info(f"Dataset vorm: {df.shape}") self.logger.info(f"Kolommen: {list(df.columns)}") self.logger.info(f"Datatypes:\n{df.dtypes}") self.logger.info(f"Ontbrekende waarden:\n{df.isnull().sum()}") def _uniform_datatypes(self, df): """Zet datatypes om naar consistente formaten""" # Numerieke kolommen numeric_cols = ['Leeftijd', 'Inkomensgegevens'] for col in numeric_cols: if col in df.columns: df[col] = pd.to_numeric(df[col], errors='coerce') # Tekstkolommen text_cols = ['Naam', 'Opmerkingen'] for col in text_cols: if col in df.columns: df[col] = df[col].astype(str) return df def _clean_text_columns(self, df): """Standaardiseert tekstkolommen""" if 'Naam' in df.columns: # Naam kapitaliseren en whitespace verwijderen df['Naam'] = df['Naam'].str.strip().str.title() if 'Opmerkingen' in df.columns: # Speciale tekens verwijderen en consistent maken df['Opmerkingen'] = df['Opmerkingen'].apply(self._standardize_text) return df def _standardize_text(self, text): """Standaardiseert tekstinvoer""" if pd.isna(text) or text == 'nan': return None # Converteer naar string en verwijder overbodige whitespace text = str(text).strip() # Verwijder speciale tekens behalve letters, cijfers en leestekens text = re.sub(r'[^\w\s.,!?-]', '', text) # Eerste letter hoofdletter, rest kleine letters if len(text) > 0: text = text[0].upper() + text[1:].lower() return text if text != '' else None def _handle_missing_values(self, df): """Behandelt ontbrekende waarden op kolomspecifieke manier""" # Voor numerieke kolommen: mediaan imputatie if 'Leeftijd' in df.columns: median_age = df['Leeftijd'].median() df['Leeftijd'] = df['Leeftijd'].fillna(median_age) if 'Inkomensgegevens' in df.columns: median_income = df['Inkomensgegevens'].median() df['Inkomensgegevens'] = df['Inkomensgegevens'].fillna(median_income) # Voor tekstkolommen: placeholder of lege string text_cols = ['Naam', 'Opmerkingen'] for col in text_cols: if col in df.columns: df[col] = df[col].fillna('Onbekend') return df def _handle_outliers(self, df): """Detecteert en corrigeert uitschieters met Z-score""" numeric_cols = ['Leeftijd', 'Inkomensgegevens'] for col in numeric_cols: if col in df.columns: # Bereken Z-scores z_scores = np.abs(stats.zscore(df[col].dropna())) # Identificeer uitschieters (Z-score > 3) outliers = z_scores > 3 if outliers.any(): self.logger.warning(f"{outliers.sum()} uitschieters gevonden in {col}") # Vervang uitschieters met mediaan median_val = df[col].median() df.loc[df[col].index[outliers], col] = median_val return df def _validate_clean_data(self, df): """Valideert de gereinigde data""" # Controleer op ontbrekende waarden missing_values = df.isnull().sum().sum() if missing_values > 0: self.logger.warning(f"Nog {missing_values} ontbrekende waarden na cleaning") # Controleer datatypes expected_dtypes = { 'Naam': 'object', 'Leeftijd': 'float64', 'Inkomensgegevens': 'float64', 'Opmerkingen': 'object' } for col, expected_type in expected_dtypes.items(): if col in df.columns and str(df[col].dtype) != expected_type: self.logger.warning(f"Onverwacht datatype voor {col}: {df[col].dtype}") # Gebruiksvoorbeeld en automatisering def automated_cleaning_pipeline(input_file, output_file): """ Volledig geautomatiseerde cleaning pipeline """ try: # Stap 1: Data inladen df = pd.read_csv(input_file) # of pd.read_excel() voor Excel # Stap 2: Cleaning uitvoeren cleaner = DataCleaner() cleaned_df = cleaner.clean_dataframe(df) # Stap 3: Schoon data opslaan cleaned_df.to_csv(output_file, index=False) print(f"Gereinigde data opgeslagen als: {output_file}") return cleaned_df except Exception as e: print(f"Fout in cleaning pipeline: {str(e)}") return None # Hoe te gebruiken: if __name__ == "__main__": # Voor eenmalig gebruik df = pd.read_csv('jouw_data.csv') cleaner = DataCleaner() cleaned_data = cleaner.clean_dataframe(df) # Voor geautomatiseerde workflow result = automated_cleaning_pipeline('input_data.csv', 'cleaned_data.csv') ``` **Automatisering en hergebruik tips:** 1. **Configuratiebestand**: Maak een JSON/YAML-bestand voor kolomspecifieke instellingen 2. **Parameterisering**: Gebruik functieparameters voor aanpasbare thresholds 3. **Logging**: Implementeer uitgebreide logging voor debugging 4. **Unit tests**: Schrijf tests voor elke cleaning functie 5. **Docker-container**: Packageer als container voor consistentie 6. **Airflow/Luigi**: Integreer in workflow management tools **Voor hergebruik met andere datasets:** ```python # Pas eenvoudig kolomnamen en regels aan class CustomDataCleaner(DataCleaner): def __init__(self, column_mapping, cleaning_rules): super().__init__() self.column_mapping = column_mapping self.cleaning_rules = cleaning_rules def custom_clean_method(self, df): # Implementeer aangepaste cleaning logic pass ``` Dit script biedt een robuuste basis die je eenvoudig kunt aanpassen voor verschillende datasets!