Hoe je Pandas DataFrame kunt gebruiken om tabellen snel te bewerken in Python

Het Pandas DataFrame is een Python-ge­ge­vens­struc­tuur die kan worden gebruikt om tabellen te maken en te bewerken. We leggen de structuur van de ge­ge­vens­struc­tuur en de be­lang­rijk­ste methoden en ei­gen­schap­pen ervan uit.

Hoe werkt Pandas DataFrame?

Pandas Da­taF­ra­mes vormen de kern van de Python Pandas-bi­bli­o­theek en maken ef­fi­ci­ën­te en flexibele ge­ge­vens­ana­ly­se in Python mogelijk. Een Pandas DataFrame is een twee­di­men­si­o­na­le ta­bel­struc­tuur met ge­num­mer­de rijen en gelabelde kolommen. Deze structuur maakt het mogelijk om gegevens te ordenen in een ge­mak­ke­lijk te begrijpen en te bewerken vorm, ver­ge­lijk­baar met spread­sheet­pro­gram­ma’s zoals Excel of Li­bre­Of­fi­ce. Elke kolom in een DataFrame kan ver­schil­len­de Python-ge­ge­vens­ty­pen bevatten, wat betekent dat een DataFrame he­te­ro­ge­ne gegevens kan opslaan, bij­voor­beeld numerieke waarden, te­ken­reek­sen en boole­aan­se waarden in één tabel.

Structuur van Pandas Da­taF­ra­mes

Een DataFrame bestaat uit drie hoofd­on­der­de­len: de gegevens, rij-indexen en ko­lom­na­men. De rij-index (of gewoon index) iden­ti­fi­ceert elke rij op unieke wijze. Standaard worden rijen ge­ïn­dexeerd met numerieke waarden, maar deze kunnen worden vervangen door te­ken­reek­sen. Het is be­lang­rijk om op te merken dat Pandas Da­taF­ra­mes nul-ge­ïn­dexeerd zijn, wat betekent dat indexen beginnen bij 0.

Close

Gebruik van Pandas Da­taF­ra­mes

Pandas Da­taF­ra­mes bieden ver­schil­len­de tech­nie­ken en methoden voor ef­fi­ci­ën­te ge­ge­vens­ver­wer­king, analyse en vi­su­a­li­sa­tie. Hieronder leert u meer over de be­lang­rijk­ste concepten en methoden voor ge­ge­vens­ma­ni­pu­la­tie met behulp van Pandas Da­taF­ra­mes.

Hoe maak je een Pandas DataFrame aan?

Als u de gewenste gegevens al in een Python-lijst of Python-woor­den­boek hebt op­ge­sla­gen, kunt u daar eenvoudig een DataFrame van maken. Geef de bestaande ge­ge­vens­struc­tuur gewoon door aan de DataFrame-con­struc­tor met behulp van pandas.DataFrame([data]). Hoe Pandas uw gegevens in­ter­pre­teert, hangt af van de structuur die u opgeeft. U kunt bij­voor­beeld als volgt een Pandas DataFrame maken op basis van een Python-lijst:

import pandas
lists = ["Ahmed", "Beatrice", "Candice", "Donovan", "Elisabeth", "Frank"]
df = pandas.DataFrame(list)
print(df)
# Output:
#            0
# 0     	Ahmed
# 1      	Beatrice
# 2     	Candice
# 3    		Donovan
# 4  	  	Elisabeth
# 5  		Frank

Zoals u in het bo­ven­staan­de voorbeeld kunt zien, kunt u met een­vou­di­ge lijsten alleen Da­taF­ra­mes maken met één enkele, niet-gelabelde kolom. Daarom wordt aan­be­vo­len om Da­taF­ra­mes te maken op basis van woor­den­boe­ken die lijsten bevatten. De sleutels worden ge­ïn­ter­pre­teerd als ko­lom­na­men en de lijsten als de bij­be­ho­ren­de gegevens. Het volgende voorbeeld il­lu­streert dit:

import pandas
datA = {
    'Name': ['Arthur', 'Bruno', 'Christoph'],
    'Age': [34, 30, 55],
    'Income': [75000.0, 60000.5, 90000.3],
}
df = pandas.DataFrame(data)
print(df)
# Output:
#         Name  Age   Income
# 0     Arthur     34  75000.0
# 1      Bruno     30  60000.5
# 2  Christoph     55  90000.3

Met deze methode heeft het DataFrame meteen de gewenste indeling en de gewenste kop­tek­sten. Als u echter niet wilt ver­trou­wen op de in­ge­bouw­de Python-ge­ge­vens­struc­tu­ren, kunt u uw gegevens ook laden vanuit een externe bron, zoals een CSV-bestand of een SQL-database. Roep gewoon de juiste Pandas-functie aan:

import pandas
import sqlalchemy
# DataFrame of CSV:
csv = pandas.read_csv("csv-data/files.csv")
# DataFrame of SQL:
engine = create_engine('postgresql://username:password@localhost:5432/mydatabase')
sql = pandas.read_sql_query('SELECT * FROM table', engine)

De Da­taF­ra­mes csv en sql in het bo­ven­staan­de voorbeeld bevatten nu alle gegevens uit de data.csv en de SQL-tabel table. Wanneer u een DataFrame maakt op basis van een externe bron, kunt u aan­vul­len­de details spe­ci­fi­ce­ren, bij­voor­beeld of de numerieke indices al dan niet in de DataFrame moeten worden opgenomen. Meer in­for­ma­tie over de aan­vul­len­de ar­gu­men­ten van de twee functies vindt u op de officiële do­cu­men­ta­tie­pa­gi­na van Pandas DataFrame.

Hoe gegevens weergeven in Pandas Da­taF­ra­mes

Met Pandas Da­taF­ra­mes kunt u niet alleen de volledige tabel weergeven, maar ook af­zon­der­lij­ke rijen en kolommen. U kunt spe­ci­fie­ke rijen en kolommen se­lec­te­ren om te bekijken. Het volgende voorbeeld il­lu­streert hoe u af­zon­der­lij­ke of meerdere rijen en kolommen kunt weergeven:

# Output 0-th line
print(df.loc[0])
# Output lines 3 to 6
print(df.loc[3:6])
# Output lines 3 and 6
print(df.loc[[3, 6]])
# Output "Occupation" column
print(df["Occupation"])
# Output "Occupation" and "Age" columns
print(df[["Occupation", "Age"]])
# Selection of multiple rows and columns
print(df.loc[[3, 6], ['Occupation', 'Age']])

In het voorbeeld wordt naar een kolom verwezen door de naam ervan tussen enkele haakjes te plaatsen, ver­ge­lijk­baar met hoe je waarden in Python-woor­den­boe­ken opvraagt. Het attribuut loc wordt daar­en­te­gen gebruikt om naar rijen te verwijzen. Met loc kun je ook logische voor­waar­den toepassen om gegevens te filteren. Het volgende codeblok laat zien hoe je alleen de rijen kunt weergeven waarin de waarde voor ‘leeftijd’ groter is dan 30:

print(df.loc[df['Age'] > 30])

U kunt echter ook het iloc gebruiken om rijen en kolommen te se­lec­te­ren op basis van hun positie in het DataFrame. U kunt bij­voor­beeld de cel weergeven die zich in de derde rij en de vierde kolom bevindt:

print(df.iloc[3, 4]) 
# Output: 
# London
 
print(df.iloc[[3, 4, 6], 4]) 
# Output: 
# 3 London
# 4 Birmingham
# 6 Preston

Hoe je met Pandas Da­taF­ra­mes door regels kunt itereren

Bij het verwerken van gegevens in Python is het vaak nodig om de rijen van een Pandas DataFrame te doorlopen om dezelfde bewerking op alle gegevens toe te passen. Pandas biedt hiervoor twee methoden: itertuples() en iterrows(). Elke methode heeft zijn eigen voor- en nadelen wat betreft pres­ta­ties en ge­bruiks­vrien­de­lijk­heid.

De methode iterrows() re­tour­neert een tuple van index en Series voor elke rij in het DataFrame. Een Series is een Pandas- of NumPy-ge­ge­vens­struc­tuur die ver­ge­lijk­baar is met een Python-lijst, maar betere pres­ta­ties biedt. U kunt af­zon­der­lij­ke elementen in de Series openen met behulp van de kolomnaam, wat de ge­ge­vens­ver­wer­king ver­een­vou­digt.

Hoewel Pandas Series ef­fi­ci­ën­ter zijn dan Python-lijsten, brengen ze toch enige prestatie-overhead met zich mee. Daarom wordt de itertuples() met name aan­be­vo­len voor zeer grote Da­taF­ra­mes. In te­gen­stel­ling tot iterrows() re­tour­neert itertuples() de volledige rij inclusief index als tuples, die beter presteren dan Series. Met tuples kunt u in­di­vi­du­e­le elementen benaderen met behulp van punt­no­ta­tie, ver­ge­lijk­baar met het benaderen van at­tri­bu­ten van een object.

Een ander be­lang­rijk verschil tussen series en tuples is dat tuples niet ver­an­der­lijk zijn. Als u dus een DataFrame wilt doorlopen met behulp van itertuples() en waarden wilt wijzigen, moet u naar het DataFrame verwijzen met het kenmerk at en de index van de tuple. Dit kenmerk werkt op vrijwel dezelfde manier als loc. Het volgende voorbeeld il­lu­streert het verschil tussen iterrows() en itertuples():

import pandas
df = pandas.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie'], 
    'Age': [25, 30, 35], 
    'Income ': [70000.0, 80000.5, 90000.3]
})
for index, row in df.iterrows():
        row['Income'] += 1000
        print(f"Index: {index}, Age: {row['Age']}, Income: {row['Income']}")
for tup in df.itertuples():
        df.at[tup.Index, 'Income'] += 1000 # Change value directly in the DataFrame using at[] 
       print(f “Index: {tup.Index}, Age: {tup.Age}, Income: {df.loc[tup.Index, 'Income']}”)
# Both loops have the same output