Gegevenstabellen met pandas in Python

Een Series bewaart een reeks waarden samen met labels. Die labels geven de waarden betekenis: een neerslagmeting hoort bij een dag en een bevolkingsaantal bij een stad. Importeer pandas en NumPy met hun gebruikelijke korte namen.

import pandas as pd
import numpy as np
rain = pd.Series([4.5, 3.0, 6.2],
                 index=["Mon", "Tue", "Wed"], name="rain_mm")

Lees waarden en labels uit

De waarden zijn 4,5, 3,0 en 6,2; de index is Mon, Tue en Wed. Zonder index= geeft pandas de labels 0, 1 en 2. Een dictionary levert beide tegelijk: pd.Series({"Lima": 10, "Oslo": 5, "Pune": 7}) haalt de labels uit de sleutels, in de volgorde van de dictionary.

Attributen beschrijven de Series zonder haakjes: rain.index bevat de labels, rain.dtype is float64, rain.name is "rain_mm" en rain.size is 3. Gebruik rain.to_numpy() als je een NumPy-array nodig hebt. Het oudere .values geeft bij verschillende datatypes verschillende soorten arrays terug; tekstgegevens kunnen een pandas-array opleveren.

Een datatype vertelt pandas welk soort waarden het opslaat. Veelvoorkomende types zijn int64 voor gehele getallen, float64 voor decimale getallen, bool voor True/False, str voor tekst en datetime64 voor datums en tijden. pandas 3 leidt voor tekst str af; oudere voorbeelden tonen vaak object.

Werk op de hele Series

Voor s = pd.Series([10, 20, 30], index=["a", "b", "c"]) levert s * 2 de waarden 20, 40 en 60 op. s > 15 levert False, True en True op. Beide behouden de labels. Deze bewerkingen zijn gevectoriseerd: één expressie werkt op de hele Series zonder Python-lus.

Zoek een label op met s["b"], dat 20 geeft. Zoek een positie op met s.iloc[0], dat 10 geeft. De expressie "b" in s controleert de index; 20 in s is False. Zelfs een geheel getal tussen vierkante haken is een label: met index [2, 0, 1] betekent s[0] label 0, niet het eerste element. Bij tekstlabels geeft s[0] in pandas 3 een KeyError.

Koppel labels bij berekeningen

a = pd.Series([1, 2, 3], index=["x", "y", "z"])
b = pd.Series([10, 20, 30], index=["y", "z", "w"])
a + b

Het gemeenschappelijke label y combineert 2 en 10 tot 12.0; z combineert 3 en 20 tot 23.0. De labels w en x komen in slechts één invoer voor en krijgen daarom NaN. Het resultaat bevat alle vier de labels. Optellen op zichtbare rijpositie zou ten onrechte 11, 22 en 33 geven.

Gebruik a.add(b, fill_value=0) als een ontbrekende waarde als nul moet tellen. De resultaten zijn w 30.0, x 1.0, y 12.0 en z 23.0. Verwante methoden zijn sub, mul en div.

Herken ontbrekende waarden

Een ontbrekend drijvendekommagetal of een ontbrekende str-waarde gebruikt NaN; een ontbrekende datum- en tijdwaarde gebruikt NaT; een ontbrekend geheel getal in een type met ondersteuning voor ontbrekende waarden gebruikt <NA>. pd.Series([1, None, 3]) wordt float64 en toont 1.0, NaN en 3.0, omdat het gewone int64 geen NaN kan bevatten.

Een DataFrame is een tweedimensionale tabel. Elke rij legt één waarneming vast, zoals een bestelling; elke kolom bevat één variabele, zoals een hoeveelheid. Kolommen kunnen verschillende datatypes hebben, maar ze delen dezelfde rijindex.

Maak een tabel uit Python-gegevens

df = pd.DataFrame({
    "product": ["Notebook", "Desk lamp", "Pen set", "Mug"],
    "quantity": [3, 1, 2, 4],
    "unit_price": [2.50, 18.00, 4.75, 6.00]
})

Elke sleutel in de dictionary wordt een kolomnaam; elke lijst levert de waarden voor die kolom. De lijsten moeten even lang zijn, zodat elke rij in elke kolom een plaats heeft. Hier zijn de indexlabels 0 tot en met 3. Lijsten met verschillende lengtes geven een ValueError.

Een lijst met dictionaries levert daarentegen één dictionary per rij. pd.DataFrame([{"a": 1, "b": 2}, {"a": 3, "c": 4}]) maakt de kolommen a, b en c. De ontbrekende b in de tweede rij en de ontbrekende c in de eerste worden NaN, dus die kolommen gebruiken float64. Een tweedimensionale NumPy-array kan ook waarden leveren, waarbij columns=[...] de kolommen namen geeft.

Lees de afmetingen van de tabel uit

df.shape is (4, 3): vier rijen en drie kolommen, in die volgorde. len(df) is 4, terwijl df.size 12 is omdat het cellen telt. df.index bevat rijlabels, df.columns bevat kolomlabels en df.dtypes geeft één datatype per kolom. Dit zijn attributen: df.shape() probeert een tuple aan te roepen en geeft een TypeError. df.T verwisselt rijen en kolommen.

Behoud een Series of een tabel

De binnenste lijst vraagt een verzameling kolommen op. Zonder die lijst geeft df["product", "unit_price"] één tuple als sleutel door. Die komt niet overeen met een van de gewone kolomnamen en geeft een KeyError.

Vierkante haken werken ook als namen spaties bevatten of samenvallen met methoden. Puntnotatie zoals df.quantity werkt alleen voor geschikte namen. Een kolom met de naam size heeft df["size"] nodig, omdat df.size het aantal cellen van de tabel betekent. Maak kolommen ook met vierkante haken: df["total"] = 5 voegt een kolom toe, terwijl df.total = 5 dat niet doet.

Kies een as

Voor numbers = pd.DataFrame({"a": [1, 2], "b": [3, 4]}) telt numbers.sum() langs de rijen op en geeft a 3 en b 7. Dit is axis=0, ook "index" genoemd. numbers.sum(axis=1) telt over elke rij op en geeft 4 en 6; deze as heet ook "columns". Bepaal eerst welk resultaat je nodig hebt: één totaal per kolom of één totaal per rij.

Als je één rij neemt, ontstaat een Series met de kolomnamen als labels. Die Series heeft één datatype nodig dat elke cel in de rij kan bevatten. Een rij met gehele getallen en drijvendekommagetallen wordt float64; een rij met tekst en getallen wordt object. De oorspronkelijke kolommen behouden hun afzonderlijke datatypes.

Rijlabels kunnen betekenis hebben, zoals een bestelnummer, of gewoon de huidige rijen aanduiden. Een bruikbare index maakt zoekopdrachten en latere resultaten gemakkelijker te interpreteren. Labels wijzigen geeft een nieuwe tabel terug, dus bewaar het resultaat met een toewijzing.

Verplaats een ID naar de index

orders = pd.DataFrame({
    "order_id": [1001, 1002, 1003],
    "product": ["Notebook", "Desk lamp", "Pen set"],
    "unit_price": [2.50, 18.00, 4.75]
})
orders_by_id = orders.set_index("order_id")

De oorspronkelijke tabel heeft standaard een RangeIndex: 0, 1 en 2. De nieuwe tabel heeft de labels 1001, 1002 en 1003. order_id is vanuit de kolommen naar de index verplaatst. orders_by_id.loc[1002] identificeert nu de rij met Desk lamp via de ID.

Als je orders.set_index("order_id") aanroept zonder het resultaat op te slaan, blijft orders ongewijzigd. Door opnieuw toe te wijzen, zoals in orders = orders.set_index("order_id"), bewaar je de nieuwe structuur. In pandas 3.1 is inplace= verouderd voor deze methoden die labels wijzigen en voor sorteren; gebruik een toewijzing.

Verplaats labels terug naar een kolom

orders_by_id.reset_index() herstelt order_id als gewone kolom en geeft een nieuwe RangeIndex. Een index zonder naam wordt een kolom met de naam index. Zo blijft de oude identiteit van de rij behouden.

reset_index(drop=True) verwijdert de oude labels. Voor een index [10, 20, 30] bewaart het gewone reset_index() die getallen in een kolom index; reset_index(drop=True) laat ze vervallen en gebruikt 0, 1 en 2. Kies na filteren of sorteren of de oude labels nuttig zijn voordat je ze verwijdert. De index opnieuw nummeren verandert de gegevenswaarden niet en maakt een sortering niet ongedaan.

Hernoem of verwijder labels

renamed = orders.rename(columns={"unit_price": "price"})
short = orders.drop(columns=["product"])
remaining = orders.drop(index=[0, 1])

rename koppelt oude labels aan nieuwe en behoudt namen die niet worden genoemd. Standaard wordt een verkeerd gespelde oude naam genegeerd, dus inspecteer .columns als een hernoeming niets lijkt te hebben gedaan. Om elke kolomnaam te vervangen, wijs je een volledige lijst toe aan orders.columns; de lengte moet overeenkomen met het aantal kolommen.

drop(columns=...) verwijdert kolommen; drop(index=...) verwijdert rijen op label. Een ontbrekend label geeft een KeyError. Na het sorteren is label 0 misschien niet langer de eerste rij: als je het verwijdert, verwijder je nog steeds de rij met label 0.

Selecteer een lijst om de kolomvolgorde te kiezen: orders = orders[["order_id", "unit_price", "product"]]. Kolommen die niet in die lijst staan, worden uit het resultaat verwijderd.

Controleer of een ID werkelijk één rij identificeert

Indexlabels kunnen worden herhaald. Controleer orders_by_id.index.is_unique voordat je ze als unieke ID's behandelt. Als label 1002 twee keer voorkomt, geeft .loc[1002] beide rijen terug als DataFrame. Bij unieke labels geeft dezelfde zoekopdracht met één label een Series terug.

Een betekenisvolle index verbetert ook samenvattingen. In een weertabel met dagen als index geeft weather["temp_c"].idxmax() een dag zoals "Thu"; met een standaardindex geeft de methode een rijnummer.

Een CSV slaat een tabel op als tekst: records staan op regels en een scheidingsteken scheidt de velden. De eerste regel bevat vaak kolomnamen. Om het bestand correct in te lezen, moet je zowel de indeling als de betekenis van de waarden vaststellen.

Lees de besteltabel in

orders = pd.read_csv("orders.csv")

Een relatief pad wordt opgelost vanuit de huidige werkmap van Python. Een verkeerde locatie geeft FileNotFoundError. Je kunt ook een absoluut pad of een URL aan read_csv doorgeven.

De voorbeelden gebruiken dit bestand. De laatste rij heeft een leeg veld voor de hoeveelheid.

order_id,date,product,category,quantity,unit_price
1001,2026-03-02,Notebook,Stationery,3,2.50
1002,2026-03-02,Desk lamp,Home,1,18.00
1003,2026-03-03,Pen set,Stationery,2,4.75
1004,2026-03-04,Mug,Home,4,6.00
1005,2026-03-04,Backpack,Bags,1,35.00
1006,2026-03-05,Notebook,Stationery,,2.50

Met de standaardinstellingen heeft het resultaat vorm (6, 6) en indexlabels 0 tot en met 5. pandas leidt datatypes af: order_id is int64, unit_price is float64 en quantity wordt ook float64 omdat het lege veld NaN wordt. De andere kolommen, waaronder date, zijn str. Een tekenreeks die op een datum lijkt, blijft tekst totdat die als datum wordt ingelezen.

Stem af op de indeling van het bestand

Voor een bestand met de regels a;b, 1,5;2 en 3,0;4 gebruik je pd.read_csv("file.csv", sep=";", decimal=","). Kolom a bevat dan 1.5 en 3.0. Als je de standaardkomma als scheidingsteken gebruikt, krijg je één kolom met de naam a;b, een teken dat je het scheidingsteken moet controleren.

index_col="order_id" maakt die kolom tijdens het inlezen de rijindex. thousands="," leest een veld zoals "1,200" als 1200; in een bestand met komma's als scheidingsteken moet het veld volgens de CSV-regels tussen aanhalingstekens staan, zodat de komma binnen het veld niet als extra scheidingsteken wordt gezien.

Behoud betekenis bij het afleiden van datatypes

Codes zoals "001" zijn identificatiecodes, geen hoeveelheden. dtype={"id": str} behoudt hun voorloopnullen. Als pandas ze eerst naar 1 converteert, kun je door dat getal terug te converteren naar tekst niet meer achterhalen hoeveel nullen het bestand bevatte.

Lege velden en veelvoorkomende markeringen zoals NA, N/A, NULL, NaN en None zijn standaard ontbrekend. Voeg een speciale markering van een bestand toe met na_values=["-"]. Dit zijn inleesregels, dus controleer de conventies van het bestand als een code op een markering voor ontbrekende waarden lijkt.

Gebruik parse_dates=["date"] om de voorbeelddatums als datum- en tijdwaarden in te lezen. In pandas 3 gebruiken deze datums een tijdsresolutie van microseconden, datetime64[us]. UTF-8 is de standaardtekencodering. Bij een UnicodeDecodeError moet je de codering van het bestand controleren en de bijpassende optie opgeven, zoals encoding="latin-1".

Als het inlezen lukt, betekent dit dat pandas het bestand kon verwerken. Het bewijst niet dat de kolommen, datatypes en ontbrekende waarden overeenkomen met wat de tabel moet voorstellen. Inspecteer het nieuwe DataFrame voordat je ermee gaat rekenen.

Controleer zichtbare rijen en afmetingen

orders.head(3)
orders.tail()
orders.shape
orders.columns.tolist()

head() toont standaard vijf rijen; head(3) toont er drie. Met tail() controleer je het einde, waar een export andere records kan bevatten. sample(3, random_state=0) geeft een reproduceerbare aselecte steekproef van drie rijen. In een notebook wordt de laatste expressie van een cel automatisch weergegeven; gebruik elders print.

Het bestelbestand moet zes rijen en zes kolommen bevatten. Een voorvertoning moet kolommen met namen tonen en de eerste bestelling als gegevens. Als het eerste record tussen de kolomnamen verschijnt, heeft het bestand waarschijnlijk geen kopregel en is header=None nodig. Als alles in één brede kolom staat, controleer dan sep.

Kolomnamen moeten exact overeenkomen, inclusief hoofdletters en spaties. orders["Product"] mislukt als de naam product is. Als je de lijst inspecteert, vallen spaties aan het einde gemakkelijker op. orders.columns = orders.columns.str.strip() verwijdert spaties aan de uiteinden van namen in de kopregel.

Lees de structuur met info

orders.info() toont het indexbereik, de naam, het aantal aanwezige waarden en het datatype van elke kolom, en het geheugengebruik. In het voorbeeld met zes rijen heeft quantity vijf aanwezige waarden; de andere kolommen hebben er elk zes. De datatypes zijn twee kolommen met drijvendekommagetallen, één kolom met gehele getallen en drie str-kolommen. orders.dtypes geeft een beknopte lijst met datatypes.

Een kolom die numeriek lijkt maar datatype str heeft, verdient aandacht: een element zoals "unknown", een eenheid zoals "12 kg" of een niet-verwerkt scheidingsteken voor duizendtallen kan verhinderen dat een numeriek datatype wordt afgeleid. Datums blijven ook tekst tenzij ze als datums worden ingelezen. Bepaal het benodigde datatype op basis van de betekenis van de kolom, niet alleen op basis van hoe die er in een voorvertoning uitziet.

Tel ontbrekende en herhaalde waarden

orders.isna().sum()
orders.isna().any(axis=1).sum()
orders.nunique()

isna() maakt een booleaanse tabel: True markeert een ontbrekende cel. Door per kolom op te tellen, tel je die cellen. Quantity heeft één ontbrekende waarde en elke andere kolom nul. Om de betrokken rijen te tellen, controleert .any(axis=1) eerst of elke rij een ontbrekende waarde heeft, waarna .sum() die rijen telt. Als je in plaats daarvan alle kolomaantallen optelt, kun je één rij meerdere keren tellen.

nunique() telt unieke aanwezige waarden: de bestellingen hebben zes ID's, vier datums, vijf producten, drie categorieën, vier hoeveelheden en vijf prijzen. Vergelijk het aantal ID's met het aantal rijen om de uniciteit te controleren, samen met het aantal ontbrekende ID's. orders.duplicated(subset="product") markeert de tweede rij met Notebook, label 5, als herhaling. Een herhaald product is hier toegestaan; een herhaald bestelnummer moet je onderzoeken.

Lees een snel numeriek overzicht

orders.describe() geeft het aantal, gemiddelde, de standaardafwijking, het minimum, de kwartielen en het maximum voor numerieke kolommen. Het aantal van quantity is vijf, dus het gemiddelde vat vijf geregistreerde hoeveelheden samen. Controleer naast datatypes ook aannemelijke bereiken en eenheden: een kolom kan numeriek zijn en toch een invoerfout bevatten. Houd het waargenomen aantal rijen en kolommen, de datatypes, aantallen ontbrekende waarden en de ID-controle bij elkaar wanneer je nieuw ingelezen gegevens beoordeelt.

Het datatype van een kolom bepaalt welke bewerkingen zinvol zijn. Een tekstkolom met "12" slaat nog steeds tekst op; je kunt daarvan niet zoals bij een numerieke kolom het gemiddelde berekenen. Converteer bewust en wijs het resultaat terug aan de tabel.

Kies strikte conversie of conversie met ontbrekende waarden bij fouten

astype converteert een Series naar een opgegeven type, zoals int, float, str of "Int64". De conversie mislukt wanneer een waarde niet in het gevraagde type kan worden weergegeven.

raw = pd.Series(["12", "7", "n/a", "3.5"])
numeric = pd.to_numeric(raw, errors="coerce")

raw.astype(float) geeft een ValueError bij "n/a". Met errors="coerce" zijn de uitvoerwaarden 12.0, 7.0, NaN en 3.5. Het element dat niet kan worden geconverteerd, wordt ontbrekend in plaats van de conversie te stoppen. Vergelijk raw.isna().sum() met numeric.isna().sum(): nul ontbrekende waarden werden er één, wat een waarde aanwijst die je moet controleren.

Typeconversie met ontbrekende waarden bij fouten is een conversieregel, geen bewijs dat elke nieuwe ontbrekende waarde onschuldig is. Gebruik de aantallen vóór en na de conversie om verlies op te sporen. Sla de conversie op in een nieuwe variabele of kolom als de ruwe tekst nuttig is om een mislukte waarde te achterhalen.

Behoud ontbrekende gehele getallen

De kolom quantity van de bestellingen bevat gehele getallen plus één NaN en is dus float64. Het gewone astype(int) mislukt omdat NaN geen gewone weergave als geheel getal heeft.

orders["quantity"] = orders["quantity"].astype("Int64")

De hoofdletter I is belangrijk: Int64 met ondersteuning voor ontbrekende waarden behoudt de ontbrekende waarde als <NA> en slaat de bekende waarden op als gehele getallen. Deze keuze past bij aantallen met ontbrekende gegevens. Daarmee wordt een hoeveelheid die daadwerkelijk een breuk bevat niet tot een geldig geheel aantal.

Scheidingstekens voor duizendtallen in tekst moet je ook verwerken. pd.Series(["1,200", "950"]).str.replace(",", "").astype(int) geeft 1200 en 950. Als het bestand zelf die conventie gebruikt, kan thousands="," die tijdens het inlezen verwerken.

Converteer datumtekst

orders["date"] = pd.to_datetime(orders["date"])
orders["date"].dt.day_name()

De conversie maakt .dt.year, .dt.month, .dt.day en .dt.day_name() mogelijk. Voor de zes bestellingsdatums zijn de dagnamen Monday, Monday, Tuesday, Wednesday, Wednesday en Thursday. Als je alleen pd.to_datetime(orders["date"]) uitvoert, krijg je een geconverteerde Series, maar blijft de oorspronkelijke kolom tekst. Met de toewijzing bewaar je het resultaat.

Sla herhaalde categorieën op

orders["category"].astype("category") slaat herhaalde labels op via een verzameling toegestane categorieën. Bij grote tabellen bespaart dit meestal geheugen. Wijs het resultaat toe om het te bewaren, net als bij andere conversies.

Het categorische datatype verandert sommige bewerkingen. De categorieën zijn standaard ongeordend, dus min() en max() geven een TypeError. De value_counts() van een categorische kolom vermeldt ook bekende categorieën die in een gefilterde selectie ontbreken, met aantal nul. Het categorische datatype is nuttig voor herhaalde labels, maar verandert zowel het gedrag als de opslag.

Met labels kun je een rij of kolom op basis van de betekenis opvragen. Met loc identificeert een bestelnummer een rij, ook als de tabel is gesorteerd. De selectie heeft een rijgedeelte gevolgd door een kolomgedeelte: df.loc[rows, columns].

Begin met een betekenisvolle index

Het bestelbestand heeft zes rijen met ID's 1001 tot en met 1006. Maak orders_by_id = orders.set_index("order_id"). De kolommen zijn, in volgorde, date, product, category, quantity en unit_price. De rijlabels zijn bestelnummers, geen posities 0 tot en met 5.

orders_by_id.loc[1003]
orders_by_id.loc[1004, "product"]

De eerste expressie geeft bestelling 1003 terug als Series: date "2026-03-03", product "Pen set", category "Stationery", quantity 2.0 en prijs 4.75. De Series heeft de naam 1003. De tweede geeft één cel terug, "Mug".

Een ontbrekend label geeft een KeyError. orders_by_id.loc[0] mislukt: een eerste rij op positie 0 betekent niet dat er een label 0 bestaat.

Selecteer verzamelingen labels

orders_by_id.loc[[1001, 1005], ["product", "unit_price"]]

Lijsten selecteren labels in de gevraagde volgorde. Dit geeft twee rijen en twee kolommen: Notebook voor 2.5, gevolgd door Backpack voor 35.0. Een lijst behoudt een tabelvormig resultaat, ook als die één label bevat: .loc[[1003]] is een DataFrame met één rij.

Een dubbele punt op zichzelf betekent alle labels langs die as. Als je de kolomselector weglaat, vraag je ook alle kolommen op.

Neem beide grenzen van een deelbereik op labels mee

orders_by_id.loc[1002:1004, "product":"quantity"]

Bij deze geordende index zijn de rijen 1002, 1003 en 1004. Het kolomdeelbereik omvat product, category en quantity. Zowel het eindlabel van de rijen als dat van de kolommen wordt meegenomen, dus de vorm is (3, 3). Als je hier de gebruikelijke Python-regel zou toepassen die het eindpunt uitsluit, zou een bedoelde rij en kolom ontbreken.

Labels blijven behouden bij sorteren

Een standaardindex kan het onderscheid tussen label en positie verhullen. Stel dat het sorteren van scores de rijlabels 3, 0, 2, 1, 4 geeft. .loc[0] selecteert nog steeds label 0, nu de tweede weergegeven rij. .iloc[0] selecteert de bovenste weergegeven rij, label 3. Bij het sorteren beweegt een rij met het label mee; de index wordt niet ongemerkt opnieuw genummerd.

Combineer een voorwaarde met kolomselectie

De rijselector kan een booleaanse Series zijn:

orders.loc[orders["unit_price"] > 5, ["product", "unit_price"]]

Dit behoudt Desk lamp voor 18.0, Mug voor 6.0 en Backpack voor 35.0, en geeft alleen de twee gevraagde kolommen terug. Het masker bepaalt welke rijen voldoen; de kolomlijst bepaalt wat wordt getoond. Met dezelfde vorm voor twee assen kun je cellen voor een wijziging aanwijzen door de selectie links van een toewijzing te zetten.

Gebruik iloc als een vraag gaat over de plaats van een rij of kolom: de eerste drie rijen, de laatste kolom of een bepaalde weergegeven cel. De selectors zijn gehele posities, onafhankelijk van de indexlabels.

Tel vanaf nul

orders.iloc[0] selecteert de eerste rij en orders.iloc[-1] de laatste. Een negatieve positie telt terug vanaf het einde. Twee posities selecteren een cel: orders.iloc[2, 2] is "Pen set" in de oorspronkelijke besteltabel, waar product kolompositie 2 heeft.

De geïndexeerde tabel orders_by_id heeft de kolommen date, product, category, quantity en unit_price. Door order_id naar de index te verplaatsen, zijn de kolomposities veranderd, zodat product nu positie 1 heeft. Code op basis van posities hangt af van deze indeling.

Stop vóór het eindpunt van een deelbereik

orders_by_id.iloc[1:3, 0:2]

De geselecteerde rijposities zijn 1 en 2, met bestellingen 1002 en 1003. De kolomposities zijn 0 en 1, date en product. Positie 3 en kolom 2 zijn uitgesloten, wat vorm (2, 2) geeft. Een leeg begin betekent het begin; een leeg eindpunt betekent het einde.

Lijsten vragen bepaalde posities op, ook een combinatie van positieve en negatieve. orders.iloc[[0, -1], [2, 5]] selecteert product en unit_price voor de eerste en laatste bestelling. Beide zijn toevallig Notebook voor 2.5.

Voorspel de vorm van het resultaat

Een scalaire selector selecteert één element langs een as en verwijdert die dimensie. Een deelbereik of lijst behoudt die as, ook als de selectie maar één element bevat. Dit is van belang als de volgende bewerking een tabel verwacht in plaats van een Series.

Verwerk het einde van een tabel

De besteltabel met zes rijen heeft geldige niet-negatieve rijposities 0 tot en met 5. orders.iloc[10] geeft een IndexError. Een deelbereik kan voorbij de tabel lopen: orders.iloc[4:100] geeft gewoon de laatste twee rijen terug. Eén ontbrekende positie is een ongeldige aanvraag voor een element, terwijl een deelbereik een bereik beschrijft dat wordt begrensd tot de beschikbare rijen.

Kies bewust voor labels of posities

Voor één cel gebruikt at labels en iat posities. orders.at[2, "product"] en orders.iat[2, 2] geven beide "Pen set" voordat de rijen anders worden gerangschikt.

Kies loc als je een ID of de betekenis van een kolom kent. Kies iloc als de plaats zelf van belang is. Om de eerste rijen met een kolomnaam te combineren, geeft orders.columns.get_loc("quantity") de positie 4 terug, zodat je orders.iloc[0:3, 4] kunt gebruiken.

Losse vierkante haken kunnen van rol wisselen: orders["product"] selecteert een kolom, maar orders[2:4] selecteert het rijdeelbereik op posities 2 en 3. Met expliciet loc en iloc is die keuze gemakkelijker te lezen.

Filteren selecteert waarnemingen die aan een vraag voldoen, zoals welke bestellingen bij Home horen en meer dan 10 per stuk kosten. Maak eerst een booleaans masker, een Series met één True of False per rij. Gebruik dat vervolgens om de overeenkomstige rijen te selecteren.

Maak en gebruik een masker

is_stationery = orders["category"] == "Stationery"
stationery = orders[is_stationery]

Het masker is True, False, True, False, False en True. De selectie behoudt labels 0, 2 en 5, die overeenkomen met bestellingen 1001, 1003 en 1006. Filteren behoudt die labels en nummert ze niet opnieuw. reset_index(drop=True) geeft opeenvolgende labels als dat nodig is.

Vergelijkingsoperatoren zijn onder andere ==, !=, <, <=, > en >=. Tekstvergelijkingen zijn exact: "home" verschilt van "Home" en ook spaties kunnen een overeenkomst verhinderen.

Combineer voorwaarden rij voor rij

is_home = orders["category"] == "Home"
is_expensive = orders["unit_price"] > 10
orders[is_home & is_expensive]

Alleen Desk lamp voldoet: de categorie is Home en de prijs is 18.0. Mug hoort bij Home maar kost 6.0. Backpack kost 35.0 maar hoort bij Bags.

Zet elke vergelijking tussen haakjes als je ze rechtstreeks schrijft:

orders[(orders["category"] == "Home") &
       (orders["unit_price"] > 10)]

Gebruik & voor en, | voor of en ~ voor niet. De haakjes houden elke vergelijking bij elkaar voordat pandas de maskers combineert. Zonder haakjes kunnen de voorrangsregels van Python proberen een tekenreeks en een Series met & te combineren, wat een TypeError geeft.

De Python-operatoren and, or en not verwachten één waarheidswaarde, geen kolom met waarheidswaarden. Als je ze op maskers gebruikt, krijg je een ValueError over een dubbelzinnige waarheidswaarde. Een gewone if orders["quantity"] > 1: heeft hetzelfde probleem. Gebruik .any() om te vragen of een rij voldoet, of .all() om te vragen of elke rij voldoet.

Tel overeenkomsten en aandelen

is_stationery.sum() is 3 omdat True als 1 telt en False als 0. is_stationery.mean() is 0.5, de fractie van de zes bestellingen die overeenkomt. Vermenigvuldig met 100 om dat uit te drukken als 50%.

Verwerk ontbrekende waarden expliciet

Bij de oorspronkelijke float64-kolom quantity geven vergelijkingen met NaN False, behalve !=, dat True geeft. quantity >= 1 behoudt vijf rijen; quantity < 1 behoudt er geen. De lege hoeveelheid zit in geen van beide selecties. Toch neemt quantity != 3 die lege rij mee, dus ongelijk aan betekent niet bekend en verschillend.

Na conversie naar Int64 met ondersteuning voor ontbrekende waarden geeft een vergelijking met <NA> de waarde <NA>, en filteren laat die rijen weg. Gebruik isna() of notna() als de vraag over ontbrekende waarden gaat.

Gebruik orders.loc[is_home, "product"] om zowel kolommen als rijen te selecteren. Dit geeft Desk lamp en Mug terug. Een benoemd masker kun je opnieuw gebruiken om dezelfde verzameling rijen te inspecteren, te tellen en te wijzigen.

Sommige filters hebben een vertrouwde vorm: voorkomen in een lijst, een numeriek interval, een ontbrekende waarde of een tekstfragment. Hulpmethoden drukken deze tests rechtstreeks uit en geven nog steeds maskers die je met andere voorwaarden kunt combineren.

Test voorkomen en bereiken

orders[orders["category"].isin(["Home", "Bags"])]
orders[orders["unit_price"].between(4.75, 18)]

isin komt overeen met elke opgegeven waarde. De eerste selectie bevat bestellingen 1002, 1004 en 1005. ~orders["category"].isin(["Home"]) keert de test om en behoudt rijen van Stationery en Bags. Een Python-expressie met in maakt dit masker voor voorkomen niet rij voor rij.

between neemt standaard beide eindpunten mee. De tweede selectie bevat Desk lamp voor 18.0, Pen set voor 4.75 en Mug voor 6.0. Gebruik inclusive="neither" om beide eindpunten uit te sluiten, "left" om alleen het lage eindpunt mee te nemen of "right" om alleen het hoge eindpunt mee te nemen. Kies de regel voor eindpunten op basis van de vraag.

Zoek ontbrekende en aanwezige waarden

orders[orders["quantity"].isna()] behoudt bestelling 1006. notna() doet het omgekeerde en behoudt geregistreerde hoeveelheden. Test geen gelijkheid met np.nan: NaN is zelfs niet gelijk aan zichzelf, dus quantity == np.nan vindt de ontbrekende rij niet.

Zoek binnen tekst

orders[orders["product"].str.contains("note", case=False, na=False)]

str.contains test of elke tekstwaarde een overeenkomst bevat. Door hoofdletters te negeren vind je beide rijen met Notebook. Met na=False telt ontbrekende tekst als geen overeenkomst. De zoekopdracht behandelt het patroon standaard als een reguliere expressie; voor een letterlijk tekstfragment met leestekens voorkomt regex=False dat die leestekens als patroon worden geïnterpreteerd. str.startswith en str.endswith testen het begin en einde.

Schrijf een filter als query

orders.query("quantity >= 2 and unit_price < 5")

Dit behoudt bestellingen 1001 en 1003. Binnen een query-tekenreeks staan kolomnamen voor kolommen en zijn and, or en not toegestaan. De tekenreeks is een pandas-queryexpressie; de syntaxis is niet dezelfde als bij het rechtstreeks combineren van Series in gewone Python.

Een Python-variabele heeft @ nodig:

limit = 5
orders.query("unit_price > @limit")

Het resultaat bevat Desk lamp, Mug en Backpack. Een kolomnaam met een spatie heeft backticks nodig binnen de query, zoals in orders.query("`unit price` > 5").

Je kunt dezelfde vraag schrijven als masker, aanroep van een hulpmethode of query. Kies bij voorkeur de vorm die de regel duidelijk laat zien. Voor een interval brengt between de grenzen en de inclusieregel samen. Voor een verzameling toegestane labels voorkomt isin herhaalde gelijkheidstests. Als een filter zich onverwacht gedraagt, inspecteer dan het masker en de exacte kolomwaarden voordat je de voorwaarde wijzigt.

Een wijziging moet gericht zijn op de tabel die je wilt veranderen. In pandas 3 gedraagt een selectie zich onder kopiëren bij schrijven als een afzonderlijk object, dus als je een geselecteerd object wijzigt, verandert de oorspronkelijke tabel niet.

Zet het volledige doel in één loc-toewijzing

sale = orders.copy()
is_home = sale["category"] == "Home"
sale.loc[is_home, "unit_price"] *= 0.9

Het masker selecteert twee rijen van Home. De kolomselector richt zich op hun prijzen. Vermenigvuldiging met 0,9 behoudt 90% van elke prijs en verlaagt 18,00 naar 16,20 en 6,00 naar 5,40. Andere rijen blijven ongewijzigd. De uitgebreide vorm leest rechts dezelfde selectie en wijst links de vermenigvuldigde waarden toe.

Hier is sale een afzonderlijke tabel voor een prijswijziging, zodat orders beschikbaar blijft ter vergelijking. Om de oorspronkelijke tabel bij te werken, zet je orders.loc[...] zelf links van de toewijzing.

Vermijd geketende toekenning

orders[orders["category"] == "Home"]["unit_price"] = 0

Dit gebruikt twee indexeringsstappen. De eerste maakt een geselecteerd object; de tweede wijst toe aan dat object. In pandas 3 werkt dit orders nooit bij, en een waarschuwing ChainedAssignmentError wijst op het probleem. Hetzelfde probleem geldt voor orders["unit_price"][1] = 0.

Gebruik orders.loc[orders["category"] == "Home", "unit_price"] = 0 als je de oorspronkelijke tabel wilt wijzigen. De tabel, overeenkomstige rijen en kolom worden allemaal in één toewijzing opgegeven.

Begrijp geselecteerde tabellen

Na home = orders[orders["category"] == "Home"] verandert een wijziging van home["unit_price"] alleen home. Latere wijzigingen in orders veranderen home evenmin. De objecten kunnen intern opslag delen totdat schrijven nodig is, maar hun zichtbare waarden gedragen zich onafhankelijk.

Oudere pandas-voorbeelden tonen mogelijk SettingWithCopyWarning en gebruiken .copy() na selectie om onzekere wijzigingen te vermijden. pandas 3 heeft die waarschuwing verwijderd en zorgt ervoor dat selecties zich consequent onafhankelijk gedragen. Een expliciete .copy() is nog steeds nuttig om je bedoeling aan te geven, maar een selectie gedraagt zich bij wijzigingen al onafhankelijk.

Koppel de waarden rechts aan het doel

Een scalaire waarde vult alle geselecteerde cellen. Een lijst heeft precies één waarde per geselecteerde rij nodig en vult die in de volgorde van de selectie. Een Series wordt uitgelijnd op indexlabel:

new_prices = pd.Series([16.2, 5.4], index=[1, 3])
sale.loc[is_home, "unit_price"] = new_prices

De Home-rijen hebben labels 1 en 3 en krijgen dus 16.2 en 5.4. Als een geselecteerd label in de Series zou ontbreken, zou de toegewezen waarde NaN zijn; rijen buiten de selectie zouden ongewijzigd blijven. Gelijke lengtes op zichzelf garanderen geen overeenkomst tussen een Series en rijen.

Inspecteer sale.loc[is_home, "unit_price"] na de wijziging en vergelijk het resultaat met orders.loc[is_home, "unit_price"]. De .sum() van het masker is 2, het verwachte aantal rijen waarop deze korting wordt toegepast.

Nieuwe kolommen zetten geregistreerde gegevens om in grootheden die je kunt analyseren. Een berekening tussen kolommen werkt rij voor rij, terwijl de index elk resultaat aan de bijbehorende waarneming gekoppeld houdt.

Bereken omzet

orders["revenue"] = orders["quantity"] * orders["unit_price"]

De zes omzetbedragen zijn 7.5, 18.0, 9.5, 24.0, 35.0 en NaN. Voor de eerste rij geven drie artikelen van 2,50 per stuk samen 7,50. De laatste rij heeft een onbekende hoeveelheid, dus de omzet is ook onbekend. Toewijzen aan een nieuwe naam voegt rechts een kolom toe; toewijzen aan een bestaande naam overschrijft die kolom.

Rekenen met kolommen is gevectoriseerd. Je drukt één regel uit voor de hele kolom en vermijdt een Python-lus over rijen. Bij grote tabellen is dit veel sneller dan for of iterrows, en de expressie maakt het verband tussen de invoerwaarden duidelijk.

Gebruik de geregistreerde waarden in een totaal

orders["revenue"].sum() slaat NaN over en geeft 94.0, het totaal van de vijf bekende omzetbedragen. .mean() geeft 18.8 omdat de noemer bestaat uit vijf geregistreerde omzetbedragen. Als je 94,0 door alle zes rijen zou delen, zou je de ontbrekende omzet ongemerkt behandelen alsof die als een bekende nul bijdroeg.

Om procentuele aandelen te berekenen:

orders["share_pct"] = (
    orders["revenue"] / orders["revenue"].sum() * 100
).round(1)

De aandelen zijn 8.0, 19.1, 10.1, 25.5, 37.2 en NaN. Dit zijn aandelen van het bekende totaal. De ontbrekende waarde blijft bij berekeningen ontbreken.

Geef een tabel terug met assign

assign geeft een nieuw DataFrame met toegevoegde of vervangen kolommen terug en laat de invoer ongewijzigd. Het past goed in een keten:

with_tax = orders.assign(
    tax=lambda d: (d["revenue"] * 0.2).round(2)
)

De lambda leest de tabel op dat punt in de keten. Die geeft belastingwaarden 1.5, 3.6, 1.9, 4.8, 7.0 en NaN. In pandas 3 is pd.col("revenue") * 0.2 een andere manier om in assign naar een kolom te verwijzen.

Decimale berekeningen kunnen kleine binaire drijvendekommafouten laten zien: 9,5 keer 0,2 kan worden opgeslagen als 1.9000000000000001. .round(2) geeft een bruikbare waarde voor presentatie. Vermijd exacte gelijkheidstests op berekende decimale getallen wanneer kleine fouten in de getalrepresentatie mogelijk zijn.

Weet hoe toewijzing rijen koppelt

orders["home_price"] = orders.loc[
    orders["category"] == "Home", "unit_price"
]

De toegewezen Series heeft labels 1 en 3. Die rijen krijgen 18.0 en 6.0; elke andere rij krijgt NaN. Toewijzing van een Series koppelt labels, ook als de lengte verschilt van die van de tabel. Een gewone lijst heeft geen labels en moet precies één waarde per rij bevatten. Een scalaire waarde, zoals in orders["currency"] = "EUR", vult elke rij.

Leid waarden af uit tekst of datums

De accessors .str en .dt bieden ook gevectoriseerde kolombewerkingen. orders["product"].str.upper() geeft namen in hoofdletters en .str.len() geeft de lengtes 8, 9, 7, 3, 8 en 8. Wijs zulke resultaten toe aan een nieuwe kolom als zowel de oorspronkelijke als de afgeleide waarden nuttig zijn.

Een kolom transformeren kan betekenen dat je een numerieke regel toepast, een label toewijst of bestaande labels omzet. Kies een methode waarvan het gedrag bij de regel past, vooral voor waarden die de regel niet noemt.

Zet een voorwaarde om in labels

orders["price_band"] = np.where(
    orders["unit_price"] >= 5, "high", "low"
)

np.where kiest het tweede argument waar de voorwaarde True is en het derde waar die False is. Voor prijzen 2,50, 18,00, 4,75, 6,00, 35,00 en 2,50 zijn de labels low, high, low, high, high en low. De >= neemt een prijs die precies gelijk is aan 5 mee.

Zet alle waarden om of wijzig er enkele

codes = {"Stationery": "ST", "Home": "HM", "Bags": "BG"}
orders["category_code"] = orders["category"].map(codes)

map met een dictionary geeft ST, HM, ST, HM, BG en ST. Een waarde die niet in de dictionary staat, wordt NaN. Met alleen {"Stationery": "ST"} worden zowel Home als Bags ontbrekend. Gebruik een volledige waardetoewijzing als elke categorie een omgezette code nodig heeft.

replace wijzigt opgegeven waarden en laat niet-opgegeven waarden ongewijzigd. orders["category"].replace({"Bags": "Luggage"}) behoudt Stationery en Home en hernoemt Bags.

Pas een eigen functie toe

Een Series kan elke waarde via map of apply aan een functie doorgeven. orders["product"].apply(len) geeft de lengte van elke productnaam terug. Geef len zelf door; len() zou de functie direct zonder waarde aanroepen.

Een lambda kan een kleine regel voor waarden uitdrukken: orders["unit_price"].apply(lambda p: "budget" if p < 5 else "standard"). Dit geeft budget, standard, budget, standard, standard en budget terug.

Voor logica die meerdere cellen in één rij nodig heeft, accepteert apply op een DataFrame axis=1:

orders.apply(
    lambda r: r["quantity"] * r["unit_price"], axis=1
)

De functie leest de hoeveelheid en prijs van elke rij. Voor deze berekening is rechtstreekse vermenigvuldiging van kolommen duidelijker en veel sneller bij een grote tabel. Gebruik gevectoriseerde expressies of np.where wanneer je de berekening daarmee kunt uitdrukken; bewaar rijgewijze functies voor logica die ze nodig heeft.

Gebruik ingebouwde numerieke transformaties

round(n) rondt af op n decimalen, abs() geeft absolute waarden en clip(lower=..., upper=...) begrenst waarden. orders["unit_price"].clip(upper=20) verandert 35.0 in 20.0 en laat de andere vijf prijzen ongewijzigd. De dure rij wordt niet verwijderd.

Deze transformaties geven nieuwe waarden terug. Wijs ze toe aan een nieuwe kolom om de invoer voor controle te bewaren, of overschrijf het origineel als dat de bedoeling is. Inspecteer enkele getransformeerde rijen of voer value_counts() uit om te controleren of nieuwe labels en hun aantallen bij de regel passen.

Sorteren verandert de volgorde waarin waarnemingen verschijnen. De waarden van elke rij blijven bij elkaar en het rijlabel beweegt mee. Bepaal wat prioriteit krijgt en hoe gelijke waarden moeten worden geordend voordat je de bovenste of onderste waarden selecteert.

Sorteer één kolom

scores = pd.DataFrame({
    "name": ["Ana", "Ben", "Chen", "Dara", "Eli"],
    "points": [88, 92, 88, 75, 92]
})
ordered = scores.sort_values("points")

Standaard komt de kleinste waarde eerst. Dara's 75 staat vooraan, gevolgd door de twee waarden 88 en daarna de twee waarden 92. Rijlabels bewegen mee met de records. Bij gelijke waarden garandeert het standaardsorteeralgoritme niet dat de oorspronkelijke volgorde behouden blijft; de weergegeven labels kunnen 3, 0, 2, 1, 4 zijn, maar je mag er niet van uitgaan dat rijen met gelijke waarden die volgorde behouden.

Gebruik ascending=False om de grootste waarde eerst te zetten. sort_values geeft een tabel terug en laat scores ongewijzigd tenzij je het resultaat toewijst.

Kies hoe gelijke waarden worden geordend

scores.sort_values(
    ["points", "name"], ascending=[False, True]
)

De eerste sleutel heeft prioriteit. Punten lopen af; namen lopen op binnen gelijke puntenaantallen. De volgorde is Ben, Eli, Ana, Chen en Dara. Eerst op naam sorteren zou een andere vraag beantwoorden, omdat namen dan de primaire sleutel zijn.

Als gelijke waarden bij sorteren op één kolom de invoervolgorde moeten behouden, gebruik je scores.sort_values("points", kind="stable"). Stabiliteit behoudt de bestaande volgorde van rijen met gelijke waarden. Een tweede sleutel geeft gelijke waarden daarentegen een eigen expliciete ordeningsregel.

Plaats ontbrekende waarden en tekst

Ontbrekende waarden komen standaard achteraan, zowel bij oplopend als aflopend sorteren. pd.Series([3.0, np.nan, 1.0]).sort_values() geeft 1.0, 3.0 en daarna NaN. na_position="first" verplaatst de ontbrekende waarde naar het begin; alleen de sorteerrichting omkeren doet dat niet.

Tekst wordt op tekencode gesorteerd. "Zebra" komt vóór "apple" omdat hoofdletters en kleine letters verschillende bereiken innemen. Consistent geschreven namen zoals Bags, Home en Stationery worden in de verwachte alfabetische volgorde gesorteerd.

Sorteer labels of nummer ze opnieuw

sort_index() ordent de rijlabels, niet de gegevenswaarden. Na sorteren op punten kan deze methode de oorspronkelijke volgorde van de standaardlabels herstellen. sort_index(ascending=False) keert de volgorde van de labels om. reset_index(drop=True) laat daarentegen de huidige rijvolgorde staan en vervangt de labels door 0, 1, 2 enzovoort.

Selecteer de grootste of kleinste rijen

scores.nlargest(2, "points") geeft Ben en Eli terug, beiden met 92. nsmallest neemt in plaats daarvan lage waarden. Als de grens binnen een groep gelijke waarden valt, bepaal je of je alle rijen met die waarde wilt behouden. scores.nlargest(1, "points", keep="all") geeft beide waarden 92 terug, ook al is n gelijk aan 1. Het gevraagde aantal is dan een grens, geen belofte over het uiteindelijke aantal rijen.

Een rangnummer legt vast waar een waarde in de gesorteerde volgorde thuishoort zonder de rij te verplaatsen. Dit is nuttig als elke waarneming naast de oorspronkelijke gegevens een plaatsnummer nodig heeft. Gelijke waarden hebben een regel nodig omdat meerdere waarden hetzelfde deel van die volgorde kunnen innemen.

Kies de richting

scores["points"].rank() rangschikt van klein naar groot. Gebruik ascending=False voor een uitslagentabel waarin hoge scores de beste rangnummers moeten krijgen. De methode voor gelijke waarden bepaalt dan welk plaatsnummer elke groep gelijke waarden krijgt.

De voorbeeldscores in rijvolgorde zijn Ana 88, Ben 92, Chen 88, Dara 75 en Eli 92. In aflopende volgorde staan de waarden 92 op plaats 1 en 2, de waarden 88 op plaats 3 en 4, en 75 op plaats 5. De standaard method="average" geeft elke gelijke waarde het gemiddelde van de ingenomen plaatsen. De teruggegeven waarden, in de oorspronkelijke rijvolgorde, zijn 3.5, 1.5, 3.5, 5.0 en 1.5.

Kies een methode voor gelijke waarden

Bij min betekenen twee winnaars met rangnummer 1 dat de volgende score begint bij rangnummer 3. Bij dense begint de volgende afwijkende score bij rangnummer 2. first kent verschillende rangnummers toe aan gelijke scores, ook als de scores zelf geen reden geven om de ene persoon boven de andere te verkiezen; de methode volgt de invoervolgorde.

Rangnummers worden als drijvendekommagetallen teruggegeven, waardoor waarden zoals 1.5 mogelijk zijn. Als een gekozen methode voor gelijke waarden hele rangnummers geeft en er geen ontbreken, converteert .astype(int) ze voor weergave. Een gewoon geheelgetaltype kan geen ontbrekend rangnummer bevatten.

Druk rangnummers uit als fracties

Bij de standaardmethode met het gemiddelde en aanwezige waarden deelt rank(pct=True) elk rangnummer door het aantal gerangschikte waarden. Als je de vijf voorbeeldscores oplopend rangschikt, krijg je 2.5, 4.5, 2.5, 1.0 en 4.5. Delen door vijf geeft 0.5, 0.9, 0.5, 0.2 en 0.9.

De gelijke hoogste waarden krijgen 0.9, niet 1, omdat hun gemiddelde rangnummer 4.5 is. Een relatief rangnummer beschrijft het rangnummer ten opzichte van de gerangschikte waarden; het is geen percentage van de score zelf.

Verwerk ontbrekende rangnummers en sla resultaten op

Ontbrekende waarden behouden standaard NaN als rangnummer. Bij omzetten 7.5, 18.0, 9.5, 24.0, 35.0 en NaN zijn de aflopende rangnummers 5, 3, 4, 2, 1 en NaN. na_option="bottom" zet de ontbrekende waarde na de geregistreerde waarden en geeft die rangnummer 6.

scores["place"] = scores["points"].rank(
    method="min", ascending=False
)

De rijen blijven Ana, Ben, Chen, Dara en Eli. De nieuwe kolom place legt 3, 1, 3, 5 en 1 vast. Sorteer afzonderlijk als de weergave de winnaars eerst moet tonen.

Een beschrijvende statistiek vat veel waarnemingen samen in één bruikbare grootheid. Kies een statistiek die bij de vraag past en lees het aantal aanwezige waarden af, zodat je weet op hoeveel gegevens die is gebaseerd.

Bereken centrum en spreiding

weather = pd.DataFrame({
    "temp_c": [14.0, 17.5, 16.0, 21.0, 19.5, 12.5, 15.0],
    "rain_mm": [0.0, 2.4, 0.0, 0.0, 5.1, 12.3, 0.8]
}, index=["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"])

Voor weather["temp_c"] is sum() 115.5, mean() 16.5 en median() 16.0. Het minimum is 12,5 en het maximum 21,0, wat een variatiebreedte van 8,5 °C geeft. idxmax() geeft het label "Thu" terug en idxmin() geeft "Sat" terug: ze identificeren waarnemingen in plaats van de uiterste waarden zelf terug te geven.

std() en var() meten spreiding. pandas gebruikt standaard de steekproefnoemer, ddof=1, en deelt gekwadrateerde afwijkingen door één minder dan het aantal. Hier is de standaardafwijking ongeveer 3,028 °C en de variantie ongeveer 9,167 graden Celsius in het kwadraat. std(ddof=0) gebruikt het aantal zelf en geeft ongeveer 2,803 °C. NumPy's np.std gebruikt standaard ddof=0, dus stem de instelling af voordat je resultaten vergelijkt.

Lees kwartielen en describe

quantile(0.25) geeft het onderste kwartiel, 14.5; quantile(0.5) geeft de mediaan, 16.0; quantile(0.75) geeft het bovenste kwartiel, 18.5. De standaardinterpolatie kan een waarde tussen geregistreerde metingen teruggeven.

weather.describe() combineert het aantal, gemiddelde, de standaardafwijking, het minimum, de drie kwartielen en het maximum voor numerieke kolommen. Neerslag heeft een gemiddelde van ongeveer 2,94 mm en een mediaan van 0,8 mm. De meting van 12,3 mm trekt het gemiddelde omhoog; de mediaan beschrijft een typische dag in deze rechtsscheve week beter.

Houd rekening met ontbrekende waarden en datatypes

Voor pd.Series([1, np.nan, 3]) is .mean() 2.0 omdat ontbrekende waarden standaard worden overgeslagen. .count() is 2, terwijl .size 3 is. Met skipna=False is het gemiddelde NaN. Gebruik het totale aantal rijen niet als noemer voor het standaardgemiddelde wanneer sommige waarden ontbreken.

Tekstsamenvattingen verschillen. orders["category"].describe() geeft count 6, unique 3, top Stationery en freq 3. Het gemiddelde berekenen van de besteltabel met tekst geeft een TypeError; gebruik orders.mean(numeric_only=True) of selecteer numerieke kolommen met select_dtypes("number").

Vat samen langs een as

Standaard reduceren DataFrame-statistieken langs de rijen tot één resultaat per kolom. axis=1 geeft daarentegen één resultaat per rij; selecteer grootheden waarvan de eenheden zinvol kunnen worden gecombineerd.

orders[["quantity", "unit_price"]].agg(["mean", "max"])

agg berekent meerdere benoemde statistieken samen. Quantity heeft gemiddelde 2.2 en maximum 4.0; unit_price heeft gemiddelde ongeveer 11,46 en maximum 35.0. weather["rain_mm"].cumsum() geeft cumulatieve totalen 0.0, 2.4, 2.4, 2.4, 7.5, 19.8 en 20.6 mm, met behoud van één resultaat per dag.

Aantallen beschrijven hoe vaak waarden voorkomen; correlaties beschrijven hoe twee numerieke variabelen samen variëren. Beide samenvattingen moet je interpreteren: wat wordt er geteld, wat ontbreekt en welk verband meet de statistiek?

Tel categorieën of toon unieke waarden

orders["category"].value_counts() geeft Stationery 3, Home 2 en Bags 1, geordend op frequentie. De teruggegeven Series heeft de naam count. Ontbrekende waarden worden standaard uitgesloten; dropna=False neemt ze op als afzonderlijk aantal.

orders["category"].value_counts(normalize=True)

De genormaliseerde Series heeft de naam proportion: Stationery is 0.5, Home ongeveer 0,333 en Bags ongeveer 0,167. Vermenigvuldigen met 100 geeft percentages. Met de standaardregel voor ontbrekende waarden beschrijven deze aandelen de aanwezige waarden.

unique() behoudt de volgorde van eerste voorkomen: Stationery, Home, Bags. mode() geeft een Series terug omdat meerdere waarden dezelfde hoogste frequentie kunnen hebben. Het is geen verzoek om één willekeurig gekozen winnaar.

Voorwaarden kun je rechtstreeks tellen. (weather["rain_mm"] > 0).sum() telt vier regendagen. De .mean() is ongeveer 0,571, dus op ongeveer 57% van de zeven dagen viel regen.

Meet een rechtlijnig verband

weather["temp_c"].corr(weather["rain_mm"]) geeft een Pearsoncorrelatie van ongeveer −0,397. Het negatieve teken geeft aan dat op warmere dagen in deze waarnemingen doorgaans minder regen viel. De grootte beschrijft hoe goed een rechtlijnig patroon past, op een schaal van −1 via 0 tot 1.

Een waarde van 1 betekent een perfect stijgend rechtlijnig verband; −1 betekent een perfect dalend verband. Een waarde dicht bij nul betekent weinig lineaire samenhang. Een kromlijnig verband kan nog steeds sterk zijn, ook als de Pearsoncorrelatie dicht bij nul ligt. Correlatie gaat bovendien over samenhang en bewijst niet dat een verandering van de ene variabele de andere doet veranderen.

Lees een correlatiematrix

weather.corr() geeft alle numerieke paren samen. De matrix is symmetrisch: temperatuur met neerslag heeft dezelfde correlatie als neerslag met temperatuur. Een variërende numerieke kolom heeft correlatie 1 met zichzelf; een constante kolom heeft geen gedefinieerde correlatie en geeft in plaats daarvan NaN.

Voor verbanden die steeds stijgen of dalen zonder een rechte lijn te volgen, berekent method="spearman" de correlatie op basis van rangnummers. De methode verandert welk soort patroon wordt samengevat, dus noem die wanneer je een resultaat rapporteert.

De weerberekening gebruikt slechts zeven metingen. Die beschrijft deze kleine waargenomen week; stevige uitspraken over een breder klimaatpatroon hebben meer bewijs nodig. Een bruikbaar rapport bevat de variabelen, het teken en de grootte van de coëfficiënt, de methode en het aantal waarnemingen.