Hvordan bruke Pandas DataFrame til å manipulere tabeller raskt i Python

Pandas DataFrame er en Python-datastruktur som kan brukes til å opprette og manipulere tabeller. Vi forklarer strukturen til datastrukturen og dens viktigste metoder og egenskaper.

Hvordan fungerer Pandas DataFrame?

Pandas DataFrames er kjernen i Python Pandas-biblioteket og muliggjør effektiv og fleksibel dataanalyse i Python. En Pandas DataFrame er en todimensjonal tabellstruktur med nummererte rader og merkede kolonner. Denne strukturen gjør det mulig å organisere data på en lett forståelig og håndterbar måte, på samme måte som i regnearkprogrammer som Excel eller LibreOffice. Hver kolonne i en DataFrame kan inneholde forskjellige Python-datatyper, noe som betyr at en DataFrame kan lagre heterogene data – for eksempel numeriske verdier, strenger og boolske verdier i en enkelt tabell.

Strukturen til Pandas DataFrames

En DataFrame har tre hovedkomponenter: dataene, radindeksene og kolonnenavnene. Radindeksen (eller bare indeksen) identifiserer hver rad unikt. Som standard er radene indeksert med numeriske verdier, men disse kan erstattes med strenger. Det er viktig å merke seg at Pandas DataFrames er nullindekserte, noe som betyr at indeksene starter på 0.

Close

Bruk av Pandas DataFrames

Pandas DataFrames tilbyr ulike teknikker og metoder for effektiv databehandling, analyse og visualisering. Nedenfor lærer du om viktige konsepter og metoder for datamanipulering ved hjelp av Pandas DataFrames.

Hvordan lage en Pandas DataFrame

Hvis du allerede har lagret ønsket data i en Python-liste eller Python-ordbok, kan du enkelt opprette en DataFrame fra den. Bare send den eksisterende datastrukturen til DataFrame-konstruktøren ved hjelp av pandas.DataFrame([data]). Hvordan Pandas tolker dataene dine, avhenger av strukturen du oppgir. Du kan for eksempel opprette en Pandas DataFrame fra en Python-liste på følgende måte:

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 enkle lister bare opprette DataFrames med en enkelt, umerket kolonne. Av denne grunn anbefales det å opprette DataFrames fra ordbøker som inneholder lister. Nøklene tolkes som kolonnenavn og listene som tilhørende data. Følgende eksempel illustrerer 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 å bruke denne metoden får DataFrame umiddelbart ønsket format og ønskede overskrifter. Hvis du ikke ønsker å bruke de innebygde Python-datastrukturene, kan du også laste inn dataene dine fra en ekstern kilde, for eksempel en CSV-fil eller en SQL-database. Bare bruk den aktuelle Pandas-funksjonen:

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)

DataFrames csv og sql i eksemplet ovenfor inneholder nå alle dataene fra data.csv og SQL-tabellen table. Når du oppretter en DataFrame fra en ekstern kilde, kan du spesifisere tilleggsdetaljer, for eksempel om de numeriske indeksene skal inkluderes i DataFrame eller ikke. Finn ut mer om tilleggsargumentene til de to funksjonene på den offisielle Pandas DataFrame-dokumentasjonssiden.

Hvordan vise data i Pandas DataFrames

Med Pandas DataFrames kan du ikke bare vise hele tabellen, men også enkeltrader og -kolonner. Du kan velge bestemte rader og kolonner som du vil vise. Følgende eksempel illustrerer hvordan du viser enkeltrader eller flere rader 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 refereres det til en kolonne ved å bruke navnet i enkeltparenteser, på samme måte som når du henter verdier i Python-ordbøker. Derimot brukes attributtet loc til å referere til rader. Med loc kan du også bruke logiske betingelser for å filtrere data. Følgende kodeblokk viser hvordan du kun kan vise rader der verdien for «age» er større enn 30:

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

Du kan imidlertid også bruke attributtet iloc til å velge rader og kolonner basert på deres posisjon i DataFrame. Du kan for eksempel vise cellen som ligger i tredje rad og fjerde kolonne:

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

Hvordan iterere over linjer med Pandas DataFrames

Når man behandler data i Python, er det ofte nødvendig å iterere over radene i en Pandas DataFrames for å bruke den samme operasjonen på alle dataene. Pandas tilbyr to metoder for dette formålet: itertuples() og iterrows(). Hver metode har sine egne fordeler og ulemper når det gjelder ytelse og brukervennlighet.

Metoden iterrows() returnerer en tuple med indeks og serie for hver rad i DataFrame. En serie er en Pandas- eller NumPy-datastruktur som ligner på en Python-liste, men som gir bedre ytelse. Du kan få tilgang til enkeltelementer i serien ved å bruke kolonnenavnet, noe som forenkler datahåndteringen.

Selv om Pandas Series er mer effektive enn Python-lister, medfører de likevel en viss ytelsesoverhead. Derfor anbefales metoden itertuples() spesielt for svært store DataFrames. I motsetning til iterrows() returnerer itertuples() hele raden, inkludert indeks, som tupler, som har bedre ytelse enn Series. Med tupler kan du få tilgang til individuelle elementer ved hjelp av punktnotasjon, på samme måte som når du får tilgang til attributter til et objekt.

En annen viktig forskjell mellom serier og tupler er at tupler ikke er mutable. Så hvis du vil iterere over en DataFrame ved hjelp av itertuples() og endre verdier, må du referere til DataFrame med at og indeksen til tuplen. Dette attributtet fungerer på samme måte som loc. Følgende eksempel illustrerer forskjellene mellom 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