Natuurlijk! Hier is een stapsgewijze gids met codevoorbeelden over hoe je effectief gegevens uit verschillende bronnen zoals CSV-bestanden, databases en API's kunt extraheren en samenvoegen in één Pandas DataFrame voor analyse. Stap 1: Installeer benodigde pakketten Zorg dat je Pandas hebt geïnstalleerd. Voor databaseverbindingen heb je mogelijk ook SQLAlchemy nodig. ```bash pip install pandas sqlalchemy requests ``` Stap 2: Importeren van benodigde modules ```python import pandas as pd import sqlalchemy import requests ``` Stap 3: Gegevens uit CSV-bestanden inlezen ```python # Inlezen van CSV-bestanden gegevens1 = pd.read_csv('gegevens1.csv') gegevens2 = pd.read_csv('gegevens2.csv') ``` Stap 4: Gegevens uit een database ophalen Bijvoorbeeld een SQLite database: ```python # Maak een engine voor de database engine = sqlalchemy.create_engine('sqlite:///mijn_database.db') # Query uitvoeren en in DataFrame laden query = 'SELECT * FROM mijn_tabel' gegevens_db = pd.read_sql(query, engine) ``` Stap 5: Gegevens via API ophalen Stel dat je data van een REST API wilt krijgen: ```python response = requests.get('https://api.example.com/data') if response.status_code == 200: data_json = response.json() gegevens_api = pd.DataFrame(data_json) else: print('API-aanroep mislukt') ``` Stap 6: Voorbereiden en opschonen van de gegevens Controleer kolomnamen, datatypes en ontbrekende waarden. ```python # Voorbeeld: kolomnamen consistent maken gegevens1.rename(columns={'oude_kolom': 'nieuwe_kolom'}, inplace=True) gegevens2.rename(columns={'oude_kolom': 'nieuwe_kolom'}, inplace=True) # Omgaan met ontbrekende waarden gegevens1.dropna(inplace=True) gegevens2.fillna(0, inplace=True) ``` Stap 7: Gegevens samenvoegen Gebruik bijvoorbeeld `merge()` of `concat()`, afhankelijk van de situatie. **Samenvoegen op basis van een gemeenschappelijke sleutel:** ```python samengevoegd = pd.merge(gegevens1, gegevens2, on='gemeenschappelijke_kolom', how='inner') ``` **Gegevens achter elkaar plakken (verticaal):** ```python alle_gegevens = pd.concat([gegevens1, gegevens2], ignore_index=True) ``` Stap 8: Best practices - Controleer kolomnamen en datatypes voordat je samenvoegt. - Gebruik `merge()` met de juiste join-type (`inner`, `left`, `right`, `outer`) afhankelijk van je behoefte. - Herstructureer je data indien nodig met `pivot()`, `melt()`. - Documenteer elke stap voor reproduceerbaarheid. Voorbeeld volledige code: ```python import pandas as pd import sqlalchemy import requests # CSV-bestanden inlezen gegevens1 = pd.read_csv('gegevens1.csv') gegevens2 = pd.read_csv('gegevens2.csv') # Database inlezen engine = sqlalchemy.create_engine('sqlite:///mijn_database.db') gegevens_db = pd.read_sql('SELECT * FROM mijn_tabel', engine) # API inlezen response = requests.get('https://api.example.com/data') if response.status_code == 200: gegevens_api = pd.DataFrame(response.json()) else: gegevens_api = pd.DataFrame() # Data voorbereiden # Voorbeeld: kolomnamen aanpassen gegevens1.rename(columns={'oude_kolom': 'gemeenschappelijke_kolom'}, inplace=True) gegevens2.rename(columns={'oude_kolom': 'gemeenschappelijke_kolom'}, inplace=True) # Samengevoegde DataFrame maken samengevoegd = pd.merge(gegevens1, gegevens2, on='gemeenschappelijke_kolom', how='inner') # Alternatief: alle gegevens samenvoegen alle_gegevens = pd.concat([gegevens1, gegevens2], ignore_index=True) # Resultaat bekijken print(samengevoegd.head()) ``` Met deze aanpak kun je gegevens uit meerdere bronnen effectief verzamelen, opschonen en samenvoegen voor je analyse.

Zeker! Hier is een gedetailleerde handleiding voor het effectief extraheren en samenvoegen van gegevens uit meerdere bronnen naar een Pandas DataFrame. ## 1. Basis Imports ```python import pandas as pd import numpy as np from pathlib import Path ``` ## 2. Gegevens Inlezen uit Verschillende Bronnen ### CSV-bestanden inlezen: ```python # Basis methode df1 = pd.read_csv('gegevens1.csv') df2 = pd.read_csv('gegevens2.csv') # Met geavanceerde opties voor betere controle df1 = pd.read_csv('gegevens1.csv', encoding='utf-8', delimiter=',', parse_dates=['datum_kolom'], # Datumkolommen direct parsen na_values=['NULL', 'NaN', '']) # Aangepaste missing values df2 = pd.read_csv('gegevens2.csv', encoding='utf-8', delimiter=',', parse_dates=['datum_kolom']) ``` ### Database connectie (voorbeeld met SQLite): ```python import sqlite3 # Verbinding maken met database conn = sqlite3.connect('database.db') # Data lezen met SQL query query = "SELECT * FROM tabel_naam" df_db = pd.read_sql_query(query, conn) # Verbinding sluiten conn.close() ``` ### API data ophalen: ```python import requests # API call maken response = requests.get('https://api.voorbeeld.com/data') api_data = response.json() # Converteren naar DataFrame df_api = pd.DataFrame(api_data) ``` ## 3. Data Exploratie en Validatie ### Basis informatie over elke dataset: ```python print("=== Dataset 1 Info ===") print(f"Vorm: {df1.shape}") print(f"Kolommen: {df1.columns.tolist()}") print(f"Data types:\n{df1.dtypes}") print(f"Ontbrekende waarden:\n{df1.isnull().sum()}") print("\n=== Dataset 2 Info ===") print(f"Vorm: {df2.shape}") print(f"Kolommen: {df2.columns.tolist()}") print(f"Data types:\n{df2.dtypes}") ``` ### Eerste en laatste rijen bekijken: ```python print("Eerste 5 rijen df1:") print(df1.head()) print("Laatste 3 rijen df2:") print(df2.tail(3)) ``` ## 4. Data Voorbewerking ### Kolomnamen standaardiseren: ```python # Kolomnamen consistent maken df1.columns = df1.columns.str.lower().str.replace(' ', '_') df2.columns = df2.columns.str.lower().str.replace(' ', '_') # Specifieke kolomnamen aanpassen indien nodig df1 = df1.rename(columns={'oude_naam': 'nieuwe_naam'}) df2 = df2.rename(columns={'oude_naam': 'nieuwe_naam'}) ``` ### Datatypes controleren en aanpassen: ```python # Datatypes controleren print("Datatypes voor samenvoegen:") print(df1.dtypes) print(df2.dtypes) # Specifieke kolommen converteren df1['categorie_kolom'] = df1['categorie_kolom'].astype('category') df2['categorie_kolom'] = df2['categorie_kolom'].astype('category') ``` ## 5. Methodes voor Samenvoegen ### Methode 1: Concatenatie (zelfde structuur) ```python # Eenvoudige concatenatie gecombineerd_df = pd.concat([df1, df2], ignore_index=True, sort=False) # Met keys voor herkomst tracking gecombineerd_df = pd.concat([df1, df2], keys=['bron1', 'bron2'], names=['bron', 'index']) ``` ### Methode 2: Merge/Join (op gemeenschappelijke kolommen) ```python # Inner join op gemeenschappelijke kolom samengevoegd_df = pd.merge(df1, df2, on='gemeenschappelijke_kolom', how='inner') # Left join met suffix voor dubbele kolomnamen samengevoegd_df = pd.merge(df1, df2, left_on='kolom_df1', right_on='kolom_df2', how='left', suffixes=('_df1', '_df2')) ``` ### Methode 3: Append (verouderd maar nog bruikbaar) ```python # Alternatief voor concat gecombineerd_df = df1.append(df2, ignore_index=True) ``` ## 6. Complete Werkschema ```python def laad_en_combineer_data(bestand_paden): """ Laad en combineer meerdere CSV-bestanden tot één DataFrame """ dataframes = [] for bestand in bestand_paden: try: # Data inlezen df = pd.read_csv(bestand, encoding='utf-8', parse_dates=True, infer_datetime_format=True) # Bron informatie toevoegen df['data_bron'] = Path(bestand).stem # Toevoegen aan lijst dataframes.append(df) print(f"✅ {bestand} succesvol geladen: {df.shape}") except Exception as e: print(f"❌ Fout bij laden {bestand}: {e}") # Alle dataframes combineren if dataframes: gecombineerd_df = pd.concat(dataframes, ignore_index=True, sort=False) print(f"🎯 Gecombineerde dataset: {gecombineerd_df.shape}") return gecombineerd_df else: print("⚠️ Geen data geladen!") return pd.DataFrame() # Gebruik: bestanden = ['gegevens1.csv', 'gegevens2.csv'] eind_df = laad_en_combineer_data(bestanden) ``` ## 7. Data Kwaliteit Controle ```python def controleer_data_kwaliteit(df): """ Uitgebreide data kwaliteitscontrole """ print("=== DATA KWALITEITS RAPPORT ===") print(f"Totaal rijen: {len(df)}") print(f"Totaal kolommen: {len(df.columns)}") print(f"Duplicaten: {df.duplicated().sum()}") print("\nOntbrekende waarden per kolom:") print(df.isnull().sum()) print(f"\nTotaal ontbrekende waarden: {df.isnull().sum().sum()}") print(f"\nGeheugen gebruik: {df.memory_usage(deep=True).sum() / 1024**2:.2f} MB") # Unieke waarden per kolom print("\nUnieke waarden per kolom:") for kolom in df.columns: print(f"{kolom}: {df[kolom].nunique()} unieke waarden") # Uitvoeren controleer_data_kwaliteit(eind_df) ``` ## 8. Geoptimaliseerde Opslag ```python # Opslaan als geoptimaliseerd bestand eind_df.to_csv('gecombineerde_data.csv', index=False, encoding='utf-8') # Of als Parquet voor betere prestaties eind_df.to_parquet('gecombineerde_data.parquet', index=False) # Met compressie eind_df.to_csv('gecombineerde_data.csv.gz', index=False, compression='gzip') ``` ## Beste Praktijken: 1. **Valideer altijd je data** voor samenvoegen 2. **Standaardiseer kolomnamen** tussen bronnen 3. **Controleer datatypes** consistent zijn 4. **Gebruik logging** voor foutafhandeling 5. **Voeg bron metadata toe** voor traceerbaarheid 6. **Maak backup** van originele data 7. **Documenteer transformatiestappen** Deze aanpak zorgt voor robuuste data-integratie en maakt toekomstige uitbreidingen eenvoudig!