Sådan bruges Pandas DataFrame til hurtigt at ma­ni­p­u­le­re tabeller i Python

Pandas DataFrame er en Python-da­ta­struk­tur, der kan bruges til at oprette og ma­ni­p­u­le­re tabeller. Vi forklarer da­ta­struk­tu­rens opbygning og dens vigtigste metoder og egen­ska­ber.

Hvordan fungerer Pandas DataFrame?

Pandas Da­ta­F­ra­mes er kernen i Python Pandas-bi­bli­o­te­ket og muliggør effektiv og fleksibel da­ta­a­na­ly­se i Python. En Pandas DataFrame er en to­di­men­sio­nal ta­bel­struk­tur med num­me­re­re­de rækker og mærkede kolonner. Denne struktur gør det muligt at or­ga­ni­se­re data i en let­for­stå­e­lig og ma­ni­p­u­ler­bar form, svarende til reg­ne­arks­pro­gram­mer som Excel eller Li­breOf­fi­ce. Hver kolonne i en DataFrame kan indeholde for­skel­li­ge Python-datatyper, hvilket betyder, at en DataFrame kan gemme he­te­ro­ge­ne data – for eksempel numeriske værdier, strenge og booleske værdier i en enkelt tabel.

Struk­tu­ren i Pandas Da­ta­F­ra­mes

En DataFrame har tre ho­ved­kom­po­nen­ter: data, ræk­ke­in­dek­ser og ko­lon­ne­nav­ne. Ræk­ke­in­dek­set (eller blot indekset) iden­ti­fi­ce­rer hver række entydigt. Som standard in­dek­se­res rækker med numeriske værdier, men disse kan erstattes med strenge. Det er vigtigt at bemærke, at Pandas Da­ta­F­ra­mes er nulin­dek­se­re­de, hvilket betyder, at in­dek­ser­ne starter ved 0.

Close

Brug af Pandas Da­ta­F­ra­mes

Pandas Da­ta­F­ra­mes tilbyder for­skel­li­ge teknikker og metoder til effektiv da­ta­be­hand­ling, analyse og vi­su­a­li­se­ring. Nedenfor kan du læse om de vigtigste begreber og metoder til da­ta­be­hand­ling ved hjælp af Pandas Da­ta­F­ra­mes.

Sådan oprettes en Pandas DataFrame

Hvis du allerede har gemt de ønskede data i en Python-liste eller Python-ordbog, kan du nemt oprette en DataFrame ud fra dem. Du skal blot overføre den ek­si­ste­ren­de da­ta­struk­tur til DataFrame-kon­struk­to­ren ved hjælp af pandas.DataFrame([data]). Hvordan Pandas fortolker dine data afhænger af den struktur, du angiver. Du kan f.eks. oprette en Pandas DataFrame fra en Python-liste på følgende måde:

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

Som du kan se i eksemplet ovenfor, kan du med simple lister kun oprette Da­ta­F­ra­mes med en enkelt, umærket kolonne. Af denne grund anbefales det at oprette Da­ta­F­ra­mes fra ordbøger, der in­de­hol­der lister. Nøglerne fortolkes som ko­lon­ne­nav­ne, og listerne som de til­knyt­te­de data. Følgende eksempel il­lu­stre­rer dette:

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

Ved hjælp af denne metode får DataFrame straks det ønskede format og de ønskede over­skrif­ter. Hvis du ikke ønsker at benytte de ind­byg­ge­de Python-da­ta­struk­tu­rer, kan du også indlæse dine data fra en ekstern kilde, f.eks. en CSV-fil eller en SQL-database. Du skal blot kalde den relevante Pandas-funktion:

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)

Da­ta­F­ra­mes csv og sql i oven­stå­en­de eksempel in­de­hol­der nu alle data fra data.csv og SQL-tabellen table. Når du opretter en DataFrame fra en ekstern kilde, kan du angive yder­li­ge­re detaljer, f.eks. om de numeriske indekser skal medtages i DataFrame eller ej. Få mere at vide om de yder­li­ge­re ar­gu­men­ter for de to funk­tio­ner på den of­fi­ci­el­le Pandas DataFrame-do­ku­men­ta­tions­si­de.

Sådan vises data i Pandas Da­ta­F­ra­mes

Med Pandas Da­ta­F­ra­mes kan du ikke kun vise hele tabellen, men også enkelte rækker og kolonner. Du kan vælge bestemte rækker og kolonner, som du vil se. Følgende eksempel viser, hvordan du viser enkelte eller flere rækker og kolonner:

# 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']])

I eksemplet henvises der til en kolonne ved at bruge dens navn i en­kelt­pa­ren­te­ser, på samme måde som man får adgang til værdier i Python-ordbøger. Derimod bruges at­tri­but­ten loc til at henvise til rækker. Med loc kan man også anvende logiske be­tin­gel­ser til at filtrere data. Følgende kodeblok viser, hvordan man kun udskriver de rækker, hvor værdien for ‘age’ er større end 30:

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

Du kan dog også bruge at­tri­but­ten iloc til at vælge rækker og kolonner baseret på deres position i DataFrame. Du kan f.eks. vise cellen, der er i tredje række og fjerde kolonne:

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

Sådan gentages linjer med Pandas Da­ta­F­ra­mes

Når man behandler data i Python, er det ofte nød­ven­digt at gentage rækkerne i en Pandas Da­ta­F­ra­mes for at anvende den samme operation på alle data. Pandas tilbyder to metoder til dette formål: itertuples() og iterrows(). Hver metode har sine egne fordele og ulemper med hensyn til ydeevne og bru­ger­ven­lig­hed.

Metoden iterrows() re­tur­ne­rer en tuple af indeks og serie for hver række i DataFrame. En serie er en Pandas- eller NumPy-da­ta­struk­tur, der ligner en Python-liste, men som tilbyder bedre ydeevne. Du kan få adgang til in­di­vi­du­el­le elementer i serien ved hjælp af ko­lon­ne­nav­net, hvilket forenkler da­ta­hånd­te­rin­gen.

Selvom Pandas Series er mere effektive end Python-lister, medfører de stadig en vis ydel­ses­over­he­ad. Derfor anbefales metoden itertuples() især til meget store Da­ta­F­ra­mes. I mod­sæt­ning til iterrows() re­tur­ne­rer itertuples() hele rækken inklusive indeks som tuples, som er mere effektive end Series. Med tuples kan du få adgang til in­di­vi­du­el­le elementer ved hjælp af prik­no­ta­tion, svarende til adgang til at­tri­but­ter for et objekt.

En anden vigtig forskel mellem serier og tupler er, at tupler ikke er mutable. Så hvis du vil iterere over en DataFrame ved hjælp af itertuples() og ændre værdier, skal du henvise til DataFrame med at­tri­but­ten at og tuplens indeks. Dette attribut fungerer meget lig loc. Følgende eksempel il­lu­stre­rer for­skel­le­ne mellem iterrows() og 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