Gegevens bewerken met pandas

Ontbrekende gegevens betekenen dat een waarde onbekend of niet beschikbaar is. pandas slaat op die plaats een speciale markering op. Spoor die markering op voordat je totalen berekent of bepaalt welke rijen bruikbaar zijn.

Herken de markeringen

De markering hangt af van het datatype. Float-kolommen gebruiken NaN, datetime-kolommen gebruiken NaT en datatypes met ondersteuning voor ontbrekende waarden, zoals "Int64", "boolean" en "string", gebruiken pd.NA. pandas 3 leidt voor tekstkolommen het type str af, met NaN voor ontbrekende tekst. Ook Python's None wordt als ontbrekend herkend. Gebruik import pandas as pd en import numpy as np voor de voorbeelden.

df.isna() maakt een booleaanse tabel met dezelfde rijen en kolommen als df. Een True markeert een ontbrekende waarde; df.notna() markeert aanwezige waarden. De alternatieve namen isnull() en notnull() doen hetzelfde. Vergelijk een kolom niet met np.nan: NaN is zelfs niet gelijk aan zichzelf, dus s == np.nan vindt de ontbrekende waarden niet.

Tel cellen en getroffen rijen

Bekijk deze weermetingen:

Een booleaanse True telt als 1, dus df.isna().sum() geeft 0 ontbrekende steden, 2 temperaturen en 2 neerslagmetingen. df.isna().mean() geeft aandelen van 0,0; 0,5 en 0,5. Voor het aandeel van elke kolom zijn alle vier de rijen de noemer.

Gebruik df.isna().any(axis=1) om getroffen rijen te vinden. Dit geeft False, True, True, True terug; optellen geeft 3. Daarentegen geeft df.isna().sum().sum() 4 ontbrekende cellen. Kyiv draagt twee cellen bij, maar slechts één getroffen rij. Gebruik de maat die antwoord geeft op je vraag.

Herken verborgen codes voor ontbrekende waarden

Een instrument kan een niet-beschikbare meting vastleggen als -999, "-" of "unknown". Dit zijn gewone waarden totdat je ze converteert. Nadat je de betekenis van de code hebt bevestigd, gebruik je df.replace([-999, "unknown"], np.nan). Bij het inlezen van CSV voegt na_values=[-999, "unknown"] deze codes toe aan de herkende markeringen. Lege CSV-velden en veelvoorkomende tekenreeksen zoals "NA", "n/a" en "NULL" worden standaard al herkend.

Een neerslagmeting van nul kan betekenen dat er geen regen is gevallen, dus als je elke nul vervangt, vernietig je echte waarnemingen. Ook zijn een lege tekenreeks die in het geheugen is gemaakt, "", en een tekenreeks met spaties voor isna() niet ontbrekend. Inspecteer opgeslagen tekst en tel niet alleen de markeringen. Gebruik value_counts(dropna=False) om ontbrekende categorieën in een frequentietabel op te nemen.

Controleer berekeningen en datatypes

Voor s = pd.Series([4, np.nan, 8]) is s.mean() 6,0: de methode gebruikt de twee bekende waarden. s.count() is 2, terwijl len(s) 3 is. Als je s.sum() deelt door len(s), krijg je 4,0 en behandel je de ontbrekende waarde ten onrechte als nul. De meeste statistieken slaan ontbrekende waarden standaard over; een kolom met uitsluitend ontbrekende waarden heeft som 0 maar gemiddelde NaN.

Een ontbrekende waarde kan ook de opslag veranderen. pd.Series([3, None, 5]) wordt float64 en bevat 3,0; NaN en 5,0. Met dtype="Int64" blijven de gehele waarden behouden en staat <NA> voor de ontbrekende waarde. De hoofdletter I duidt het pandas-geheelgetaltype met ondersteuning voor ontbrekende waarden aan.

Als je een rij verwijdert, verwijder je behalve de ontbrekende waarden ook de bekende waarden. Als je een ontbrekende waarde aanvult, behoud je de rij maar voeg je een schatting toe. Kies op basis van de betekenis van de waarneming en de kolommen die de analyse nodig heeft.

Bepaal welke rijen worden verwijderd

df.dropna() verwijdert elke rij met een ontbrekende waarde. In de weertabel blijft alleen Lima over. Beperk de keuze met subset of stel met thresh een minimumaantal aanwezige cellen in.

axis="columns" verwijdert kolommen met ontbrekende waarden en behoudt hier alleen city. In een brede tabel kan de standaardregel voor rijen veel gegevens verwijderen, omdat een ontbrekende waarde in een willekeurige kolom al genoeg is. Vergelijk len(df) voor en na het verwijderen.

Ken het resultaat toe

Leer de vorm met een nieuwe toekenning: df = df.dropna(). Opschoningsmethoden geven standaard een nieuw object terug. pandas 3.1 raadt inplace=True af voor onder meer de methoden dropna, drop_duplicates en rename.

Voor één kolom schrijf je df["temp_c"] = df["temp_c"].fillna(0). Een geketende aanroep zoals df["temp_c"].fillna(0, inplace=True) wijzigt het bovenliggende DataFrame nooit onder het kopiëren bij schrijven van pandas 3. Met een toekenning maak je duidelijk waar het resultaat terechtkomt.

Vul aan met een passende waarde

Met een dictionary per kolom kun je een gemengde tabel passende waarden geven: df.fillna({"rain_mm": 0, "city": "Unknown"}). Kolommen die niet in de dictionary staan behouden hun ontbrekende waarden. Een scalaire waarde zoals 0 is handig voor een tabel met alleen numerieke waarden waarvan alle kolommen die waarde accepteren. Tekst aanvullen met een getal is niet toegestaan; pandas 3.1 waarschuwt hiervoor en een toekomstige versie zal het afwijzen.

De bekende temperaturen zijn 18,0 en 31,0. Hun gemiddelde is 24,5, dus df["temp_c"].fillna(df["temp_c"].mean()) vult beide ontbrekende waarden met 24,5. Een extreme waarde kan het gemiddelde sterk beïnvloeden; de mediaan is minder gevoelig. Bewaar vóór het aanvullen een indicator met df["temp_missing"] = df["temp_c"].isna(), zodat geschatte en waargenomen waarden te onderscheiden blijven.

Aanvullen met het gemiddelde verkleint de zichtbare spreiding van de kolom. Een ver verwijderde vaste waarde kan die vergroten. Als je neerslag aanvult met 0, stel je dat er geen regen is gevallen; dat is ongepast als een sensor uitstond.

Gebruik naburige metingen als de volgorde ertoe doet

ffill() neemt de laatst bekende waarde vooruit over; bfill() neemt de eerstvolgende bekende waarde achteruit over. Voor 12,0; NaN; NaN; NaN; 15,0 geeft voorwaarts opvullen vier waarden van 12,0 gevolgd door 15,0. ffill(limit=1) vult alleen de eerste ontbrekende waarde in die reeks aan. Een ontbrekende waarde aan het begin heeft geen vorige waarde en blijft ontbreken. Gebruik ffill() rechtstreeks; fillna(method="ffill") is in pandas 3 verwijderd.

interpolate() schat tussen naburige posities. Voor 10, NaN, NaN, 16 geeft lineaire interpolatie 10, 12, 14, 16. Dit past bij geleidelijk veranderende metingen in een betekenisvolle volgorde. Waarden overnemen of interpoleren tussen steden die geen verband hebben, zou een relatie opleggen die de rijen niet hebben.

Voer na elke bewerking isna().sum() opnieuw uit en controleer ook de rijaantallen. Een geslaagde methodeaanroep vertelt je dat de code is uitgevoerd; deze controles laten zien wat er is veranderd.

Twee rijen kunnen op elkaar lijken zonder dezelfde gebeurtenis te beschrijven. Bepaal voordat je duplicaten verwijdert welke waarden één record identificeren. Een bestel-ID kan een bestelling identificeren; een klant en datum alleen kunnen meerdere geldige aankopen aanduiden.

Markeer de extra kopieën

df.duplicated() geeft één booleaanse waarde per rij terug. Standaard vergelijkt de methode alle kolommen, behoudt ze de eerste keer dat een rij voorkomt en markeert ze latere kopieën met True. Als je het resultaat optelt, tel je extra kopieën, niet alle leden van herhaalde groepen.

Bekijk zes bestelrijen met ID's 101, 102, 102, 103, 104, 104. De twee rijen voor 102 zijn identiek. De twee rijen voor 104 hebben verschillende geregistreerde gewichten, 0,5 kg en 0,8 kg. Als alle kolommen worden vergeleken, is er één extra kopie: df.duplicated().sum() is 1. df.drop_duplicates() behoudt vijf rijen omdat de twee verschillende rijen voor 104 geen exacte kopieën zijn.

Vergelijk de kolommen die de identiteit bepalen

df.duplicated(subset=["order_id"]) vergelijkt alleen ID's. Dit markeert de tweede 102 en de tweede 104, wat twee extra kopieën geeft. De waarden in de andere kolommen beïnvloeden deze beslissing niet meer. Inspecteer de tegenstrijdige gewichten voordat je kiest welk bestelrecord je behoudt.

df.drop_duplicates(subset="order_id", keep="last") behoudt in deze volgorde de versie van 0,8 kg van bestelling 104. De laatste rij behouden betekent op zichzelf niet dat je het nieuwste record behoudt. Stel die volgorde eerst vast:

latest = df.sort_values("updated").drop_duplicates(
    subset="customer_id", keep="last"
)

Sorteren op updated plaatst oudere records vóór nieuwere. De controle op duplicaten vergelijkt daarna alleen customer_id, zodat verschillende bijwerktijden niet verhinderen dat twee rijen als versies van dezelfde klant worden herkend.

Onderscheid rijwaarden van indexlabels

Deze methoden vergelijken waarden en negeren indexlabels. Identieke rijen met de labels 4 en 9 tellen nog steeds als duplicaten. Ontbrekende waarden op overeenkomstige posities tellen bij deze controle als gelijk. Gebruik df.index.duplicated() om de labels zelf op herhaling te controleren.

Een exacte vergelijking behoudt ook verschillen in hoofdletters en witruimte. De waarden “ Lisbon”, “lisbon” en “LISBON ” zijn verschillend. Schoon ze op met .str.strip().str.lower() voordat je op duplicaten controleert als deze schrijfwijzen dezelfde stad aanduiden. Anders telt nunique() drie namen voor één plaats.

Controleer uniciteit waar de relatie dat vereist

Een opzoektabel hoort één rij per opzoeksleutel te hebben als elk record één set gegevens moet krijgen. lookup["customer_id"].is_unique controleert die eis. Herhaalde klant-ID's in een besteltabel zijn normaal, omdat een klant meerdere bestellingen kan plaatsen.

Als een opzoeksleutel wordt herhaald, herhaalt een latere samenvoeging elke bijpassende bestelling voor elke bijpassende rij in de opzoektabel. Als je duplicaten uit de bestellingen verwijdert, gooi je echte aankopen weg zonder de opzoektabel te herstellen. Controleer de bedoelde sleutel in de juiste tabel, inspecteer tegenstrijdige records en vergelijk het aantal rijen na het verwijderen.

Een vervanging wijzigt overeenkomende waarden, een opzoektabel vertaalt waarden en een hernoeming wijzigt labels. Deze taken kunnen er in code vergelijkbaar uitzien, maar geven verschillende resultaten als een waarde niet in een dictionary staat.

Vervang exacte waarden

s.replace("N/A", np.nan) wijzigt alleen cellen die gelijk zijn aan "N/A". Een lijst kan meerdere oude waarden bevatten: s.replace(["-", "?"], np.nan). Een dictionary geeft afzonderlijke vervangingen, zoals s.replace({"M": "male", "F": "female"}). Waarden zonder overeenkomst blijven zoals ze waren.

Voor een hele tabel beperkt een geneste dictionary de wijziging tot één kolom: df.replace({"status": {0: "open", 1: "closed"}}). Zo voorkom je dat andere nullen en enen elders veranderen. Ken het teruggegeven resultaat toe om de wijziging te behouden.

replace vergelijkt volledige cellen. Bij “Main St” en “St” verandert s.replace("St", "Street") alleen “St”. Gebruik s.str.replace("St", "Street", regex=False) om delen van een tekenreeks te wijzigen; dit levert ook “Main Street” op.

Wijs waarden toe via een opzoektabel

Vergelijk voor de codes “PT”, “JP” en “KE” dezelfde dictionary in twee methoden:

Een dictionary die je aan map geeft, bepaalt de beschikbare uitvoerwaarden. Een ontbrekende sleutel heeft geen uitvoer en wordt een ontbrekende waarde. Controleer achteraf isna().sum() zodat een onvolledige opzoektabel zichtbaar wordt.

map accepteert ook een functie: s.map(lambda x: x * 1000) zet waarden in kilometers om naar meters. Voor deze berekening is s * 1000 eenvoudiger en sneller, omdat de expressie op de hele kolom werkt. DataFrame.map past een functie cel voor cel toe; het vervangt de verwijderde methode applymap.

Converteer tekst naar getallen

astype vraagt om een datatype, zoals "float64", "Int64" of "category". De methode geeft een fout als een waarde niet kan worden geconverteerd. Voor de tekst "12", "7.5" en "n/a" geeft pd.to_numeric(s, errors="coerce") daarentegen 12,0, 7,5 en NaN. Deze typeconversie met ontbrekende waarden bij fouten behoudt leesbare getallen, maar vereist dat je de mislukte conversies inspecteert.

Opmaak kan conversie verhinderen, ook als het getal geldig is. Verwijder voor “1,200” en “950” eerst het scheidingsteken voor duizendtallen:

cleaned = s.str.replace(",", "", regex=False)
numbers = pd.to_numeric(cleaned, errors="coerce")
failed = s.notna() & numbers.isna()

Hier markeert failed waarden die vóór de conversie aanwezig waren maar daarna ontbreken. Het vergelijken van aantallen ontbrekende waarden geeft een bruikbaar totaal; het masker wijst ook de oorspronkelijke tekst aan die je kunt inspecteren. Verwijder bekende eenheden op dezelfde zorgvuldige manier uit tekst met metingen voordat je converteert.

Hernoem de labels

df.rename(columns={"Qty": "quantity"}) wijzigt een kolomkop en laat de cellen ongewijzigd. df.rename(columns=str.lower) maakt alle kolomkoppen klein. Een reeks zoals df.columns.str.strip().str.lower().str.replace(" ", "_", regex=False) zet “Total KG ” om in total_kg; ken die toe aan df.columns.

Gebruik replace of map voor waarden binnen een kolom. Gebruik rename voor de labels waarmee je die waarden selecteert.

Sommige analyses hebben exacte metingen nodig, andere groepen of vergelijkbare numerieke bereiken. Houd de oorspronkelijke betekenis helder: klasse-indeling maakt categorieën, schalen verandert de numerieke schaal en begrenzen vervangt extreme waarden.

Plaats waarden in intervallen

pd.cut(ages, [18, 30, 45, 65]) gebruikt de intervallen (18, 30], (30, 45] en (45, 65]. Het ronde haakje sluit het linkergrenspunt uit; het vierkante sluithaakje sluit het rechtergrenspunt in. De leeftijden 19, 25 en 30 vallen in het eerste interval, 41 in het tweede en 64 in het derde. Leeftijd 18 wordt ontbrekend omdat die op de uitgesloten linkergrens ligt.

include_lowest=True neemt die laagste waarde op in het eerste interval. right=False maakt daarentegen links gesloten intervallen zoals [18, 30), zodat 30 in het tweede interval valt. Waarden buiten alle intervallen blijven ontbreken. Test zowel de exacte grenzen als gebruikelijke waarden ertussen.

Er moet één label per interval zijn, één minder dan het aantal grenzen. Met labels=["18-30", "31-45", "46-65"] en include_lowest=True geven de zes leeftijden hierboven de aantallen 4, 1 en 1. Deze labels beschrijven leeftijden in hele jaren; de intervalgrenzen blijven de indeling bepalen.

Kies grenzen of groepsgroottes

Voor 2, 4, 6, 8, 10, 12, 14, 16 geeft qcut twee waarden per kwartielgroep. Groepen met gelijke aantallen hoeven geen even brede numerieke bereiken te beslaan.

Schaal zonder groepen te maken

Min-maxschaling gebruikt (x - x.min()) / (x.max() - x.min()). Voor 10, 20, 40 is het bereik 30: de resultaten zijn 0; ongeveer 0,333 en 1. Zowel het minimum als het maximum is nodig; alleen delen door het maximum is een andere bewerking. Een constante kolom heeft een bereik van nul, dus deze expressie kan die geen bruikbare geschaalde spreiding geven.

Standaardiseren gebruikt (x - x.mean()) / x.std(). Voor 10, 20, 30 is het gemiddelde 20 en is de standaard gebruikte steekproefstandaardafwijking van pandas 10. Als je 20 aftrekt en door 10 deelt, krijg je de z-scores -1, 0 en 1. Een z-score beschrijft de afstand tot het gemiddelde in eenheden van de standaardafwijking, geen intervallabel.

Begrens en codeer

pd.Series([5, 12, 250, 8]).clip(upper=100) geeft 5, 12, 100, 8. Anders dan een filter behoudt clip de rij en vervangt het het extreme getal. Inspecteer grote waarden met describe() of een filter voordat je ze begrenst: een echte grote meting blijft een gegeven.

pd.get_dummies(s) maakt één booleaanse indicatorkolom per categorie. Bij rood, groen, rood, blauw is elke rij alleen True in de kolom van de eigen kleur. Gebruik dtype=int voor nullen en enen. Ontbrekende waarden geven uitsluitend onware indicatoren, tenzij dummy_na=True een kolom voor ontbrekende waarden toevoegt. Bij gewone kleinste-kwadratenregressie met een intercept verwijdert drop_first=True een overbodige categoriekolom; andere modellen kunnen elke categorie behouden. Met één categorie per rij telt de volledige set indicatoren op tot de constante 1 van het intercept, wat lineaire afhankelijkheid veroorzaakt.

Voor cellen met meerdere labels splitst s.str.get_dummies(sep="|") een waarde zoals “Action|Comedy” in afzonderlijke indicatoren. Je kunt ook ingedeelde intervallen aan get_dummies doorgeven, wat een kolom voor elk bereik oplevert.

Een mens ziet dezelfde stad in “ Lisbon”, “lisbon” en “LISBON ”. pandas ziet drie verschillende tekenreeksen. Door een tekstkolom op te schonen, krijgen latere tellingen, controles op duplicaten en samenvoegingen een consistente verzameling waarden om te vergelijken.

Pas tekenreeksmethoden toe op een Series

Python's "Lima ".strip() werkt op één tekenreeks. Gebruik voor een kolom de .str-accessor: s.str.strip() verwijdert witruimte aan de buitenkant van elke aanwezige waarde. s.lower() geeft een AttributeError, omdat de Series zelf geen methode lower heeft. Gebruik s.str.lower().

pandas 3 leidt voor tekst normaal gesproken het datatype str af, dat de oudere standaard object vervangt. Het datatype str bevat tekst en ontbrekende waarden, met NaN voor ontbrekende tekst. Tekenreeksmethoden werken op beide types. Ken tekst toe aan een str-kolom; zet een getal eerst om in tekst als het daar als tekst thuishoort.

Combineer passende opschoningsbewerkingen en ken het resultaat toe:

df["city"] = df["city"].str.strip().str.lower()

De drie schrijfwijzen van Lisbon worden “lisbon”. strip() verwijdert witruimte aan de buitenkant, geen spaties binnen een naam. upper() maakt alle letters hoofdletters, terwijl title() elk woord met een hoofdletter schrijft en “new york” omzet in “New York”. Kies één consistente vorm voor sleutels en tellingen.

Splits gestructureerde tekenreeksen

Voor “Silva, Ana” en “Tanaka, Yui” geeft s.str.split(", ") lijsten terug zoals ["Silva", "Ana"]. Voeg expand=True toe om afzonderlijke kolommen te maken. Haal met .str[0] of .str.get(1) een deel uit elke lijst op.

Gebruik n=1 als alleen het eerste scheidingsteken een waarde moet splitsen. Als je “a,b,c” met n=1 bij komma's splitst, krijg je “a” en “b,c”. Zonder limiet krijg je drie delen. Gebruik exact het juiste scheidingsteken, inclusief eventuele spaties die bij het formaat horen.

Zoek en filter

s.str.contains("lis", case=False) controleert of tekst ergens voorkomt en negeert daarbij het verschil tussen hoofdletters en kleine letters. s.str.startswith("ID") controleert het begin; s.str.endswith(".csv") controleert het einde. Met de booleaanse resultaten kun je rijen selecteren:

mask = df["city"].str.contains("san", case=False, na=False)
selected = df[mask]

Bij het str-datatype van pandas 3 geeft ontbrekende tekst in deze zoektests False. Door na=False te schrijven maak je ook duidelijk hoe je ontbrekende waarden wilt behandelen bij tekenreeksgegevens die ontbrekende waarden ondersteunen. contains leest standaard een regex-patroon; voeg regex=False toe voor letterlijke tekst met speciale tekens.

Vervang delen en maak nieuwe tekenreeksen

s.str.replace("kg", "", regex=False) verwijdert “kg” overal waar het voorkomt. s.replace("kg", "") wijzigt alleen cellen die precies “kg” zijn. Dit verschil is van belang voor waarden zoals “12 kg”.

str.replace behandelt de zoektekst standaard letterlijk. Voor “3.5 kg” verwijdert .str.replace(".", "", regex=False) de punt en geeft het “35 kg”. Met regex=True is de punt een patroon voor bijna elk teken en verwijdert de methode in dit voorbeeld van één regel alle tekens. Gebruik die wijziging nooit om een decimale meting in te lezen.

s.str.len() telt tekens; een ontbrekende waarde levert NaN op en kan van het resultaat een float-kolom maken. s.str[:3] haalt de eerste drie tekens op. Om kolommen te combineren voegt df["first"] + " " + df["last"] Ana en Silva samen tot “Ana Silva”; str.cat is een andere methode om samen te voegen. Elke bewerking geeft een resultaat terug, dus sla dat op in de kolom die je wilt gebruiken.

Een reguliere expressie, of regex, beschrijft een patroon in tekst. Daarmee kun je een hoeveelheid herkennen, ook als het aantal cijfers of de tussenruimte varieert. Begin met een klein patroon waarvan je de onderdelen kunt uitleggen.

Lees de onderdelen van het patroon

Schrijf Python-patronen als ruwe tekenreeksen, zoals r"\d+", zodat Python de backslashes behoudt. Een punt komt standaard overeen met elk teken behalve een nieuwe regel. Schrijf die als r"\." om een echte punt te vinden. Bij zoeken naar gewone tekst voorkomt regex=False dat de tekst als patroon wordt geïnterpreteerd.

Kies hoeveel tekst moet overeenkomen

contains vindt een patroon overal in de tekst, match begint aan het begin en fullmatch vereist dat de hele waarde overeenkomt. Voor “123a” slagen s.str.contains(r"\d+") en s.str.match(r"\d+"), maar mislukt s.str.fullmatch(r"\d+"). Gebruik de test voor de hele tekenreeks als je een volledige code controleert. Met case=False of flags=re.IGNORECASE na import re kun je hoofdletterongevoelig zoeken waar dat wordt ondersteund.

Leg een meting vast

Neem “Rice 5 kg”, “Flour 2kg”, “Salt” en “Beans 12 kg, 3 kg”. Het patroon r"(\d+)\s*kg" betekent één of meer cijfers vastgelegd als groep, gevolgd door nul of meer spaties en dan “kg”.

quantity = s.str.extract(r"(\d+)\s*kg", expand=False)
quantity = pd.to_numeric(quantity)

De opgehaalde tekenreeksen zijn “5”, “2”, een ontbrekende waarde en “12”. Conversie geeft de numerieke waarden 5,0, 2,0, NaN en 12,0. extract neemt de eerste overeenkomst in elke rij, dus de tweede hoeveelheid in de beschrijving van de bonen wordt niet meegenomen. Zonder expand=False geeft één groep een DataFrame met één kolom terug.

Benoemde groepen geven de uitvoer een naam. s.str.extract(r"(?P<year>\d{4})-(?P<month>\d{2})") vindt “2024-03” in “Report 2024-03 final” en geeft de tekstkolommen year en month terug. Het patroon herkent de indeling van de cijfers; numerieke conversie is een afzonderlijke stap.

Vind elke overeenkomst of schoon op met een patroon

findall(r"\d+") geeft een lijst per rij, waaronder ["12", "3"] voor de bonentekst en [] voor “Salt”. count(r"\d+") telt overeenkomsten. extractall geeft één rij per overeenkomst met een extra indexniveau genaamd match.

Met regex=True brengt s.str.replace(r"\s+", " ", regex=True) reeksen witruimte terug tot één spatie. r"\D" betekent een teken dat geen cijfer is, dus als je die tekens verwijdert, wordt “+351 912-345-678” omgezet in “351912345678”. De hoofdlettervormen \S en \W zijn op vergelijkbare wijze de ontkenning van de klassen voor witruimte en woordtekens.

Herhaling is standaard gretig. In "<b>x</b>" loopt r"<.*>" van het eerste openingsteken tot het laatste sluitingsteken. Als je die overeenkomst verwijdert, verdwijnt alles. Het luie patroon r"<.*?>" komt overeen met elke tag afzonderlijk en laat “x” achter. Controleer voorbeelduitvoer voordat je een patroon op een hele kolom gebruikt.

Een kolom met enkele waarden die vaak worden herhaald, kan het datatype category gebruiken. Dat slaat de unieke labels eenmaal op en geeft elke rij weer met een kleine gehele code. De zichtbare waarde blijft het label.

Begrijp categorieën en codes

Voor de maten M, S, L, M, M leidt s.astype("category") de categorieën L, M, S af in alfabetische volgorde. De codes zijn 1, 2, 0, 1, 1. Gebruik s.cat.categories om de labels te inspecteren en s.cat.codes om de identificatiecodes te inspecteren. Een code 0 betekent de eerste opgeslagen categorie; het is geen gemeten hoeveelheid.

Bij herhaalde labels kun je aanzienlijk op geheugen besparen. Tot en met 126 categorieën gebruikt elke code één byte; bij 127 categorieën zijn dat twee bytes. In een pandas 3.1-omgeving met PyArrow gebruikten drie landnamen die over 3.000.000 rijen werden herhaald ongeveer 3 MB als categorische gegevens, ongeveer 42 MB als str en ongeveer 165 MB als object. De gebruikte methode voor tekstopslag beïnvloedt deze cijfers. Een kolom met bijna uitsluitend unieke waarden heeft geen voordeel van een categorielijst plus een code per rij.

Definieer een betekenisvolle volgorde

In alfabetische volgorde komt L vóór M en S. Definieer de werkelijke volgorde van de maten expliciet:

size_type = pd.CategoricalDtype(["S", "M", "L"], ordered=True)
sizes = s.astype(size_type)

Nu volgt sorteren de volgorde S, M, L, zijn vergelijkingen zoals sizes > "S" betekenisvol en is sizes.max() “L” als L voorkomt. Voor ongeordende labels zoals landen werken gelijkheidsvergelijkingen, maar groter-danvergelijkingen geven een TypeError. as_ordered() gebruikt de bestaande volgorde van categorieën; inspecteer die voordat je die volgorde als betekenisvol aanmerkt.

Wijzig de toegestane labels

Je kunt “XL” niet toekennen aan een categorische kolom die alleen S, M en L toestaat. Ken eerst het uitgebreide resultaat toe, sizes = sizes.cat.add_categories("XL"), en ken daarna de nieuwe waarde toe.

Als je tekst naar een vaste categorielijst converteert, kunnen waarden die niet in de lijst staan ontbrekend worden. pandas 3.1 waarschuwt dat deze conversie met gegevensverlies een fout zal worden. Controleer de bronwaarden vóór de conversie met value_counts(), vooral nadat je schrijfwijzen hebt opgeschoond.

De .cat-methoden hebben verschillende doelen:

• rename_categories({"S": "small"}) wijzigt een label en behoudt de bijbehorende waarden.
• remove_categories("L") verwijdert een toegestaan label en maakt bestaande L-waarden ontbrekend.
• set_categories([...]) vervangt de hele categorielijst.
• reorder_categories([...], ordered=True) wijzigt de volgorde zonder te wijzigen welke labels zijn toegestaan.
• remove_unused_categories() verwijdert labels waartoe momenteel geen waarden behoren.

value_counts() toont elke toegestane categorie, ook die met nul waarnemingen. Bij een S/M/L-type dat alleen S en M bevat, verschijnt L nog steeds met aantal 0. Zo wordt een lege groep zichtbaar waarvoor gewone tekstgegevens geen label hebben opgeslagen.

Houd categorieën bruikbaar in latere stappen

cut levert categorische intervallen op en get_dummies zet categorielidmaatschap om in indicatorkolommen. Als je ongeordende landcodes als getallen aan een model geeft, leg je een kunstmatige volgorde en afstand op. Indicatoren voorkomen die interpretatie.

Als je categorische kolommen met verschillende categorielijsten concateneert, gaat het categorische datatype normaal gesproken verloren. Stem hun categorielijsten eerst op elkaar af of gebruik in pandas 3.1 pd.concat(..., union_categories=True) als het de bedoeling is de lijsten te combineren. Inspecteer zowel het resulterende datatype als de volgorde van de categorieën.

Een samenvoeging koppelt rijen via sleutelwaarden en plaatst hun informatie naast elkaar. De sleutel moet in beide tabellen hetzelfde aanduiden, zoals de klant-ID op een bestelling en de klant-ID in een opzoektabel.

Benoem de sleutel en kies de join

Gebruik orders.merge(customers, on="customer_id"). Zonder on gebruikt pandas alle kolomnamen die beide tabellen delen. Een gedeelde kolom zonder verband, zoals date, zou dan geldige klantkoppelingen kunnen verhinderen.

Stel dat bestellingen de klant-ID's 10, 20, 20, 30, 50 hebben. De klantentabel heeft elk één rij voor 10, 20, 30, 40.

Inner is de standaardinstelling. Bij een left join ontbreken de klantgegevens voor klant 50. Een right join bevat klant 40 zonder bestelling, plus beide bestellingen voor 20. Een outer join bevat beide sleutels zonder overeenkomst. Een cross join heeft geen sleutel nodig, omdat die bewust elke rij koppelt. pandas 3 biedt ook left_anti en right_anti voor rijen zonder overeenkomende sleutel aan de andere kant.

Controleer hoeveel overeenkomsten een rij kan hebben

Twee linkerrijen voor sleutel 20 en drie rechterrijen voor sleutel 20 leveren zes paren op. De samenvoeging kiest niet één rechterrij. Als je in het voorbeeld een tweede rij voor klant 20 aan de opzoektabel toevoegt, groeit het inner-resultaat van vier naar zes rijen.

Geef de bedoelde relatie aan met validate:

merged = orders.merge(
    customers, on="customer_id", how="left",
    validate="many_to_one"
)

Dit staat veel bestellingen per klant toe, maar vereist unieke klant-ID's aan de rechterkant. Een herhaalde rechtersleutel geeft een MergeError. one_to_one vereist uniciteit aan beide kanten; one_to_many vereist die aan de linkerkant. many_to_many staat herhalingen aan beide kanten toe en controleert de uniciteit niet.

Onderzoek rijen zonder overeenkomst

Een outer join met indicator=True voegt _merge toe. Hier zijn de aantallen vier both, één left_only en één right_only. Dit zijn rijen, geen unieke sleutels: herhaalde bestellingen kunnen voor één klant meerdere both-rijen opleveren.

Gebruik m.loc[m["_merge"] == "left_only", "customer_id"].nunique() om unieke sleutels zonder overeenkomst aan de bestelkant te tellen. Door de rijen te inspecteren kun je ontbrekende vermeldingen in de opzoektabel of inconsistente tekst ontdekken.

Bepaal namen en sleutelformaten

Als sleutels verschillende namen hebben, gebruik je left_on="customer_id", right_on="id". Beide sleutelkolommen blijven beschikbaar. Je kunt meerdere sleutels samen vergelijken met on=["city", "year"]; beide moeten overeenkomen.

Overlappende namen van kolommen die geen sleutel zijn krijgen _x en _y. Kies betekenisvolle achtervoegsels zoals suffixes=("_order", "_ship") om de herkomst duidelijk te houden.

Sleutels hebben compatibele datatypes en gelijke waarden nodig. De numerieke waarde 1 kan overeenkomen met de numerieke waarde 1,0, maar een gehele sleutelkolom en een tekstsleutelkolom kunnen bij het samenvoegen een fout geven. Converteer hun formaten bewust. “ana” en “Ana ” verschillen als tekst; standaardiseer het hoofdlettergebruik en de spaties aan de buitenkant vóór het samenvoegen als ze dezelfde persoon aanduiden.

Ook ontbrekende sleutels moet je inspecteren: pandas koppelt ontbrekende sleutels aan de ene kant aan ontbrekende sleutels aan de andere kant. Als beide kanten meerdere van zulke rijen bevatten, kunnen ook die overeenkomsten zich vermenigvuldigen.

Een index kan de sleutel bevatten waarop je wilt koppelen. pandas gebruikt die labels bij het koppelen van tabellen, het aanvullen van ontbrekende waarden of het optellen van twee Series. De rijpositie alleen bepaalt de overeenkomsten niet.

Koppel op indexlabels

left.join(right) koppelt de twee indexen en gebruikt standaard een left join. Daarentegen gebruikt merge standaard een inner join. Je kunt ook left.merge(right, left_index=True, right_index=True) schrijven als beide sleutels in de index staan.

Stel dat stations de indexlabels A, B, C en de hoogtes 120, 850, 15 m heeft. Een metingentabel heeft de stationindexlabels A, B, B, D. readings.join(stations) behoudt vier rijen en voegt de hoogtes 120, 850, 850 en NaN toe. Beide B-metingen krijgen de hoogte van B. Met how="inner" blijven alleen de drie metingen van A en B behouden.

Als de metingen station-ID's in een gewone kolom bewaren, gebruik je readings.join(stations, on="station"). De linkerkolom wordt gekoppeld aan de rechterindex. De overeenkomstige vorm met merge is readings.merge(stations, left_on="station", right_index=True, how="left").

Maak de plaats van de sleutel duidelijk

set_index("station") verplaatst de stationskolom naar de index. reset_index() zet die terug als gewone kolom. Zo kun je een indeling kiezen waarin de koppeling eenvoudig te inspecteren is. left.join([t1, t2]) kan meerdere tabellen met gemeenschappelijke indexlabels tegelijk koppelen.

Als beide gekoppelde tabellen een kolom bevatten die geen sleutel is, zoals source, geeft join een ValueError tenzij je de namen onderscheidt. Schrijf in pandas 3.1 suffixes=("_left", "_right"); dit vervangt de oudere argumenten lsuffix en rsuffix. De achtervoegsels behouden beide versies zonder te bepalen welke waarde leidend is.

Vul ontbrekende waarden aan vanuit een reservebron

a.combine_first(b) behoudt bekende waarden in a, vult de ontbrekende waarden aan vanuit b bij overeenkomende labels en neemt labels op die alleen in b voorkomen.

Het resultaat behoudt 1 en 3 omdat de eerste bron die al kent. Het gebruikt 20 om de ontbrekende waarde aan te vullen en voegt label d met 40 toe. Als je de aanroep omdraait, verandert welke bron voorrang heeft. Dit is nuttig als een hoofdbron voorrang moet krijgen op een reservebron, ook wanneer hun rijvolgorde verschilt.

Herken uitlijning bij berekeningen

Laat x de waarden a = 5 en b = 7 hebben en y de waarden b = 1 en c = 2. x + y geeft b = 8, met ontbrekende resultaten bij a en c omdat bij elk één operand ontbreekt. De eerste waarde van x wordt niet bij de eerste waarde van y opgeteld.

x.add(y, fill_value=0) vult de ontbrekende kant aan met nul en levert a = 5, b = 8, c = 2 op. Gebruik die regel als een afwezige bijdrage als nul moet tellen. Uitlijning op labels is het gemeenschappelijke principe achter deze bewerkingen, maar hun regels voor waarden verschillen: join voegt kolommen toe, combine_first vult ontbrekende waarden aan en rekenen gebeurt met overeenkomende waarden.

Maandbestanden bevatten meestal meer rijen met hetzelfde soort waarneming. Concatenatie verzamelt die delen in één tabel. Daarbij worden labels op de andere as uitgelijnd; er wordt niet gezocht naar overeenkomende klant- of bestelsleutels.

Stapel rijen en lijn kolommen uit

pd.concat([jan, feb]) stapelt rijen omdat axis=0 de standaardinstelling is. Stel dat januari drie ritten heeft met de kolommen trip en km, terwijl februari twee ritten heeft met trip, km en note. Het resultaat heeft vijf rijen en drie kolommen. De ontbrekende cellen van januari in note worden NaN.

join="outer" is de standaardinstelling: die behoudt de vereniging van kolomnamen. join="inner" behoudt alleen gemeenschappelijke namen, zodat het resultaat vijf rijen en de twee kolommen trip en km heeft. Het bevat nog steeds alle vijf waarnemingen; de joininstelling bepaalt wat er op de andere as gebeurt.

De kolomvolgorde in de delen bepaalt de koppeling niet. De exacte namen doen dat wel. Als het ene deel km gebruikt en het andere Km, bevat het resultaat twee gedeeltelijk lege kolommen. Hernoem de kolomkoppen vóór de concatenatie.

Bepaal wat de rijlabels moeten betekenen

De oorspronkelijke indexen blijven standaard behouden. Met beginindexen 0, 1, 2 en 0, 1 herhaalt het resultaat de labels 0 en 1. result.loc[0] selecteert twee rijen. Gebruik ignore_index=True als die getallen geen betekenis hebben en je nieuwe labels van 0 tot en met 4 wilt.

Als de herkomst van belang is, gebruik je een buitenste indexniveau:

result = pd.concat(
    [jan, feb], keys=["jan", "feb"], names=["month", "row"]
)

Nu selecteert result.loc["feb"] de twee rijen van februari. keys bewaart de herkomst binnen een MultiIndex. In pandas 3 geeft de combinatie van keys met ignore_index=True een ValueError; kies voor die bewerking herkomstlabels of een nieuwe gewone index.

Plaats kolommen naast elkaar

pd.concat([x, y], axis=1) lijnt rijen uit op indexlabel. Voor x met a = 1, b = 2 en y met b = 3, c = 4 heeft het resultaat de rijen a, b, c. De kolom x ontbreekt bij c en y bij a. Met join="inner" blijft alleen b over.

Controleer opslag en verzamel delen efficiënt

Een kolom die numerieke waarden en tekst mengt, kan het datatype object krijgen. Als gewone NumPy-gegevens van het type int64 een ontbrekende waarde krijgen, worden ze float64; pandas-"Int64" kan gehele getallen met <NA> behouden. Stem datatypes vóór het combineren op elkaar af als de kolom een vastgelegd type heeft.

DataFrame.append is in pandas 2.0 verwijderd. Verzamel voor veel bestanden DataFrames in een lijst en roep pd.concat na de lus één keer aan. Als je in elke iteratie een groeiend resultaat opnieuw opbouwt, kopieer je de verzamelde gegevens steeds opnieuw en wordt het traag.

Controleer of de lengte van een rijconcatenatie gelijk is aan de som van de invoerlengtes. Inspecteer daarna kolomnamen, aantallen ontbrekende waarden en datatypes.

Een MultiIndex geeft elke rij meerdere labels. Een verkooprij kan worden geïdentificeerd door zowel stad als jaar, geschreven als een tuple zoals ("Osaka", 2024). Elk label heeft een niveau en de volgorde van die niveaus is van belang bij het selecteren.

Maak en benoem de index

df.set_index(["city", "year"]) verplaatst die kolommen naar de index. pd.MultiIndex.from_product([["Lima", "Osaka"], [2024, 2025]], names=["city", "year"]) maakt elke combinatie van de opgegeven labels. Concatenatie met keys voegt ook een niveau toe.

Voor de voorbeelden heeft sales deze indexparen en waarden:

Na het instellen van de twee indexniveaus is df.index.names gelijk aan ["city", "year"]. rename_axis(["town", "yr"]) wijzigt de namen van de niveaus zonder hun waarden te wijzigen.

Selecteer een buitenste label of een volledige tuple

df.loc["Osaka"] selecteert beide rijen van Osaka. Het geselecteerde stadsniveau valt weg, zodat 2024 en 2025 als index overblijven. df.loc[("Lima", 2025), "sales"] selecteert één cel en geeft 95 terug.

Eén label dat je aan loc doorgeeft, zoekt op het buitenste niveau. df.loc[2024] zoekt daarom naar een stad met de naam 2024 en geeft in deze tabel een KeyError. Gebruik df.xs(2024, level="year") om een jaar over alle steden heen te selecteren. Dit geeft 120 voor Osaka en 80 voor Lima terug, met stad als overblijvende index.

Voor een algemenere selectie behoudt df.loc[pd.IndexSlice[:, 2025], :] alle steden voor het jaar 2025. De dubbele punt op de eerste positie betekent alle labels op dat niveau; de laatste dubbele punt selecteert alle kolommen.

Sorteer voordat je een deelbereik selecteert

Voor selectie op een exact label hoeft niet de hele index gesorteerd te zijn, maar voor een deelbereik van labels is passende sortering nodig. Gebruik df.sort_index() vóór df.loc["Lima":"Osaka"]. Een ongesorteerde MultiIndex kan bij zo'n deelbereik een UnsortedIndexError geven.

sort_index() sorteert alle niveaus in hun huidige volgorde, dus eerst de steden en binnen elke stad de jaren. sort_index(level="year") sorteert op het genoemde niveau. swaplevel("city", "year") plaatst jaar op de buitenste positie; gebruik daarna sort_index() om de nieuwe indeling te groeperen en te sorteren. Alleen de posities van de niveaus verwisselen sorteert de rijen niet.

Verplaats labels terug naar kolommen

reset_index() zet beide niveaus terug als kolommen. reset_index(level="year") zet alleen jaar terug en laat stad als index staan. Met deze bewerkingen kun je een tabel voorbereiden om samen te voegen of op te slaan zonder de identificerende waarden te verliezen.

Ook kolommen kunnen meerdere niveaus hebben. Een herstructurering met verkoop- en personeelswaarden kan kolomlabels zoals ("sales", 2024) en ("staff", 2025) opleveren. df["sales"] selecteert alle kolommen onder het bovenste label sales.

Voor een totaal per stad geeft df.groupby(level="city")["sales"].sum() Lima 175 en Osaka 255. Gebruik groepering voor deze samenvatting; het oude argument sum(level="city") is in pandas 2.0 verwijderd.

stack en unstack veranderen waar labels staan. Waarden behouden hun identificerende combinatie, maar de tabel kan combinaties zichtbaar maken waarvoor geen waarneming bestaat.

Verplaats kolomlabels naar de index met stack

Stel dat een breed DataFrame de steden Osaka en Lima als index en de jaren 2024 en 2025 als kolommen heeft. Osaka heeft de waarden 120 en 135; Lima heeft 80 en 95. Noem de assen city en year om hun betekenis zichtbaar te houden.

long = wide.stack() verplaatst de jaarlabels naar een nieuw binnenste indexniveau. Met deze kolommen met één niveau is het resultaat een Series met vier waarden:

• ("Osaka", 2024) geeft 120.
• ("Osaka", 2025) geeft 135.
• ("Lima", 2024) geeft 80.
• ("Lima", 2025) geeft 95.

De stadslabels worden herhaald omdat elke stad nu één rij per jaar heeft. Bij het stapelen zijn de waarden niet opgeteld en zijn geen extra metingen gemaakt.

Verplaats een indexniveau naar kolommen met unstack

long.unstack() verplaatst het binnenste indexniveau, jaar, naar kolommen en herstelt de brede indeling. long.unstack("city") verplaatst in plaats daarvan stad, met jaren als rijen en steden als kolommen. Een numerieke niveaupositie zoals unstack(0) kan hetzelfde niveau selecteren, maar een naam maakt de bedoeling makkelijker leesbaar.

Als de invoer hiërarchische kolommen heeft, kan na het stapelen van één niveau een ander niveau als kolommen overblijven. Voor kolommen zoals ("sales", 2024) en ("staff", 2024) geeft stack("year") een DataFrame met verkoop- en personeelskolommen terug. Het stapelen van alle kolomniveaus geeft een Series terug.

Houd ontbrekende combinaties zichtbaar

Stel nu dat de lange Series geen waarde voor Lima in 2025 heeft. Bij unstack ontstaat een rechthoekige tabel van stad bij jaar, waardoor op die plaats NaN wordt ingevoegd. Gewone gehele waarden worden floats als deze ontbrekende cel een float-markering voor ontbrekende waarden vereist.

unstack(fill_value=0) kan een nieuw ontbrekende combinatie met nul vullen. Gebruik dit alleen als afwezigheid nul betekent, zoals geen geregistreerde verkopen in een volledige dataset met verkoopgebeurtenissen. Een ontbrekende sensorwaarneming is onbekend en moet ontbreken blijven.

stack() in pandas 3 behoudt ontbrekende cellen. Het stapelen van de onvolledige tabel van 2 × 2 geeft daarom vier waarden terug, inclusief NaN. Voeg .dropna() toe als je alleen de drie bekende waarden wilt. Door ontbrekende waarden te verwijderen verandert welke combinaties vertegenwoordigd blijven, dus controleer de lengte van het resultaat.

Los dubbele combinaties eerst op

Unstack heeft één waarde per volledige indexcombinatie nodig. Twee waarden met het label ("Lima", 2025) moeten in dezelfde uitvoercel komen en geven de fout ValueError: Index contains duplicate entries, cannot reshape.

Gebruik long.index.duplicated() om herhaalde volledige labels te inspecteren, of controleer de bijbehorende sleutelkolommen voordat je de index instelt. Bepaal of de rijen onbedoelde kopieën zijn of afzonderlijke waarnemingen die moeten worden gecombineerd. Ze verwijderen of aggregeren is een beslissing over de gegevens; unstack kiest geen regel voor je.

In lang formaat staan identificerende kolommen naast één waardekolom. In breed formaat zijn metingen verdeeld over kolommen, zoals één kolom per jaar. Kies de indeling die de volgende taak eenvoudig maakt: lange tabellen zijn geschikt voor filteren en groeperen, terwijl brede tabellen vergelijking naast elkaar ondersteunen.

Zet unieke combinaties met pivot om in cellen

Een lange tabel met de kolommen city, year en sales wordt breed met df.pivot(index="city", columns="year", values="sales"). Stadslabels vormen rijen, jaren vormen kolommen en verkopen vullen de cellen. Dit is gelijk aan df.set_index(["city", "year"])["sales"].unstack().

De verkopen van Osaka in 2024 en 2025, 120 en 135, worden twee cellen in één rij. De waarden 80 en 95 van Lima vormen de tweede rij. Als je de argumenten index en columns verwisselt, transponeer je deze indeling. Als je values weglaat, worden alle overige gegevenskolommen omgezet en kunnen hiërarchische kolommen ontstaan, zoals een verkoopniveau en een personeelsniveau boven de jaren.

Bepaal of herhalingen fouten of waarnemingen zijn

pivot herschikt waarden en kan ze niet combineren. Twee rijen voor Lima in 2025 zouden twee waarden in één uitvoercel vereisen en geven daarom een ValueError. Tel herhaalde combinaties met df.duplicated(subset=["city", "year"]).sum().

Als afzonderlijke waarnemingen moeten worden gecombineerd, gebruik je pivot_table met een gekozen aggregatie. Voor de waarden 95 en 105 bij Lima in 2025 geeft het standaardgemiddelde 100,0. Met aggfunc="sum" is de cel 200. Als elke combinatie één keer had moeten voorkomen, blijf dan pivot gebruiken zodat een gegevensfout zichtbaar wordt in plaats van ongemerkt te worden samengevat.

Zet met melt meetkolommen om in rijen

Stel dat een CSV de kolommen city, 2023, 2024 en 2025 geeft. De waarden van Osaka zijn 110, 120, 135; die van Lima zijn 70, 80, 95. Zet de jaarkolommen om:

long = wide.melt(
    id_vars="city", var_name="year", value_name="sales"
)

id_vars blijft staan en wordt herhaald. Elk label van een meetkolom wordt een jaarwaarde; elke cel wordt een verkoopwaarde. Twee rijen en drie meetkolommen leveren zes lange rijen op, waaronder een rij zoals Osaka, “2023”, 110. Ook ontbrekende meetcellen worden rijen, tenzij je die achteraf verwijdert.

Omdat deze kolomlabels uit CSV-tekst kwamen, zijn de resulterende jaren tekst. Gebruik long["year"] = long["year"].astype(int) voordat je ermee rekent. Gehele kolomlabels in de invoer zouden al gehele jaarwaarden opleveren.

Bepaal wat melt omzet en herstel de vorm

value_vars=["2024", "2025"] beperkt de omzetting tot die kolommen. Als je id_vars vergeet, kunnen stadsnamen in dezelfde waardekolom als de metingen terechtkomen. Maak altijd onderscheid tussen identificatiekolommen en kolommen die waarden bevatten.

Zonder expliciete namen heet de waardekolom value. De variabelekolom neemt wide.columns.name over of heet variable als die naam leeg is. Expliciete var_name en value_name maken het resultaat makkelijker te gebruiken.

Zet de zes rijen met index="city", columns="year", values="sales" terug om de drie jaarkolommen te herstellen. Na pivot is stad de index en heet de kolomas jaar. reset_index() herstelt stad als kolom en rename_axis(columns=None) verwijdert de naam van de kolomas. Controleer zowel de vorm als de labels voordat je de tabel samenvoegt of opslaat.