Hur man använder Pandas DataFrame för att snabbt manipulera tabeller i Python

Pandas DataFrame är en datastruktur i Python som kan användas för att skapa och manipulera tabeller. Vi förklarar datastrukturens uppbyggnad och dess viktigaste metoder och egenskaper.

Hur fungerar Pandas DataFrame?

Pandas DataFrames är kärnan i Python Pandas-biblioteket och möjliggör effektiv och flexibel dataanalys i Python. En Pandas DataFrame är en tvådimensionell tabellstruktur med numrerade rader och märkta kolumner. Denna struktur gör det möjligt att organisera data i en lättförståelig och hanterbar form, liknande kalkylbladsprogram som Excel eller LibreOffice. Varje kolumn i en DataFrame kan innehålla olika Python-datatyper, vilket innebär att en DataFrame kan lagra heterogena data – till exempel numeriska värden, strängar och booleska värden i en enda tabell.

Strukturen hos Pandas DataFrames

En DataFrame har tre huvudkomponenter: data, radindex och kolumnnamn. Radindexet (eller helt enkelt index) identifierar varje rad unikt. Som standard indexeras raderna med numeriska värden, men dessa kan ersättas med strängar. Det är viktigt att notera att Pandas DataFrames är nollindexerade, vilket innebär att indexen börjar på 0.

Close

Användning av Pandas DataFrames

Pandas DataFrames erbjuder olika tekniker och metoder för effektiv databehandling, analys och visualisering. Nedan lär du dig om viktiga begrepp och metoder för datamanipulation med Pandas DataFrames.

Hur man skapar en Pandas DataFrame

Om du redan har sparat önskade data i en Python-lista eller Python-ordbok kan du enkelt skapa en DataFrame från den. Skicka bara den befintliga datastrukturen till DataFrame-konstruktorn med hjälp av pandas.DataFrame([data]). Hur Pandas tolkar dina data beror på den struktur du tillhandahåller. Du kan till exempel skapa en Pandas DataFrame från en Python-lista på följande sätt:

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 exemplet ovan kan du med enkla listor endast skapa DataFrames med en enda, omärkt kolumn. Av denna anledning rekommenderas det att skapa DataFrames från ordböcker som innehåller listor. Nycklarna tolkas som kolumnnamn och listorna som tillhörande data. Följande exempel illustrerar detta:

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

Med denna metod får DataFrame omedelbart önskat format och önskade rubriker. Om du inte vill förlita dig på de inbyggda Python-datastrukturerna kan du också ladda dina data från en extern källa, till exempel en CSV-fil eller en SQL-databas. Använd bara lämplig 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)

DataFrames csv och sql i exemplet ovan innehåller nu alla data från data.csv och SQL-tabellen table. När du skapar en DataFrame från en extern källa kan du ange ytterligare detaljer, till exempel om de numeriska indexen ska inkluderas i DataFrame eller inte. Läs mer om de ytterligare argumenten för de två funktionerna på den officiella dokumentationssidan för Pandas DataFrame.

Hur man visar data i Pandas DataFrames

Med Pandas DataFrames kan du visa inte bara hela tabellen utan även enskilda rader och kolumner. Du kan välja specifika rader och kolumner att visa. Följande exempel illustrerar hur man visar enskilda eller flera rader och kolumner:

# 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 exemplet refereras till en kolumn genom att använda dess namn inom enkla parenteser, på samma sätt som man kommer åt värden i Python-ordböcker. Däremot används attributet loc för att referera till rader. Med loc kan man också tillämpa logiska villkor för att filtrera data. Följande kodblock visar hur man endast visar rader där värdet för ”ålder” är större än 30:

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

Du kan dock också använda attributet iloc för att välja rader och kolumner baserat på deras position i DataFrame. Du kan till exempel visa cellen som finns i den tredje raden och den fjärde kolumnen:

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

Hur man itererar över rader med Pandas DataFrames

När man bearbetar data i Python är det ofta nödvändigt att iterera över raderna i en Pandas DataFrames för att tillämpa samma operation på alla data. Pandas erbjuder två metoder för detta ändamål: itertuples() och iterrows(). Varje metod har sina egna fördelar och nackdelar när det gäller prestanda och användarvänlighet.

Metoden iterrows() returnerar en tupel med index och serie för varje rad i DataFrame. En serie är en Pandas- eller NumPy-datastruktur som liknar en Python-lista, men som erbjuder bättre prestanda. Du kan komma åt enskilda element i serien med hjälp av kolumnnamnet, vilket förenklar datahanteringen.

Även om Pandas Series är effektivare än Python-listor, medför de fortfarande en viss prestandaöverbelastning. Därför rekommenderas metoden itertuples() särskilt för mycket stora DataFrames. Till skillnad från iterrows() returnerar itertuples() hela raden inklusive index som tupler, som är mer prestandastarka än Series. Med tupler kan du komma åt enskilda element med hjälp av punktnotation, på samma sätt som när du kommer åt attribut för ett objekt.

En annan viktig skillnad mellan serier och tupler är att tupler inte är muterbara. Om du vill iterera över en DataFrame med itertuples() och ändra värden måste du referera till DataFrame med attributet at och tuplens index. Detta attribut fungerar på ett mycket liknande sätt som loc. Följande exempel illustrerar skillnaderna mellan iterrows() och 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