Pandas & NumPy Academy · Lektion

pd.concat för att stapla DataFrames

Stapla DataFrames vertikalt eller horisontellt med pd.concat, justera efter index eller kolumner och hantera duplicerade index.

Lektion 1 av 413 steg

pd.concat för att stapla DataFrames är en gratis lektion i Pandas & NumPy Academy på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Pandas & NumPy Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Pandas & NumPy Academy innehåller totalt 4 lektioner.

Varför sammanfoga DataFrames?

I verkliga projekt kommer data sällan i en enda fil. Ni kan ha månatliga försäljningsfiler, regionala enkätexporter eller resultat från databasfrågor som är uppdelade på flera frågor. Sammanfogning staplar dessa separata DataFrames till en kombinerad tabell. Pandas tillhandahåller pd.concat() för detta och hanterar både vertikal (radvis) och horisontell (kolumnvis) stapling.

Grundläggande vertikal sammanfogning

Det vanligaste användningsområdet för pd.concat() är att stapla DataFrames vertikalt (lägga till fler rader). Skicka en lista med DataFrames, så lägger funktionen dem efter varandra. För ett rent resultat måste DataFrames ha kompatibla kolumner. Pandas matchar automatiskt kolumnnamnen och fyller saknade kolumner med NaN.

import pandas as pd

jan = pd.DataFrame({'product': ['A', 'B'], 'sales': [100, 200]})
feb = pd.DataFrame({'product': ['A', 'C'], 'sales': [150, 120]})

combined = pd.concat([jan, feb])
print(combined)
#   product  sales
# 0       A    100
# 1       B    200
# 0       A    150
# 1       C    120

Återställa index efter concat

Observera att pd.concat() bevarar de ursprungliga indexen från varje DataFrame, vilket kan ge duplicerade indexvärden (som ovan med två rader på index 0 och index 1). Skicka ignore_index=True för att skapa ett nytt sekventiellt heltalsindex i det kombinerade resultatet, vilket nästan alltid är det Ni vill ha.

combined = pd.concat([jan, feb], ignore_index=True)
print(combined)
#   product  sales
# 0       A    100
# 1       B    200
# 2       A    150
# 3       C    120

print(combined.index)
# RangeIndex(start=0, stop=4, step=1)

Spåra källa med keys

När Ni sammanfogar data från flera källor kanske Ni vill veta från vilken ursprunglig DataFrame varje rad kommer. Skicka parametern keys med en lista av etiketter. Pandas skapar ett MultiIndex där den yttre nivån identifierar källan. Därefter kan Ni använda .loc['label'] för att komma åt rader från en specifik källa.

combined = pd.concat([jan, feb], keys=['January', 'February'])
print(combined)
#                product  sales
# January   0         A    100
#           1         B    200
# February  0         A    150
#           1         C    120

# Access only February rows
print(combined.loc['February'])

Horisontell sammanfogning med axis=1

Skicka axis=1 för att sammanfoga DataFrames bredvid varandra (lägga till fler kolumner). Pandas matchar radindexet, så båda DataFrames bör ha samma index för ett rent resultat. Om indexen skiljer sig fylls rader som inte matchar med NaN. Detta är användbart när Ni kombinerar funktioner som beräknats från samma dataset i separata steg.

names = pd.DataFrame({'name': ['Alice', 'Bob', 'Carol']}, index=[1, 2, 3])
scores = pd.DataFrame({'score': [95, 88, 72]}, index=[1, 2, 3])

combined = pd.concat([names, scores], axis=1)
print(combined)
#     name  score
# 1  Alice     95
# 2    Bob     88
# 3  Carol     72

Hantera kolumner som inte matchar

Om DataFrames som ska sammanfogas har olika kolumner behåller Pandas alla kolumner och fyller saknade värden med NaN. Detta är standardbeteendet för join='outer'. Om Ni endast vill behålla kolumner som finns i alla DataFrames skickar Ni join='inner', vilket tar bort kolumner som saknas i någon källa.

df1 = pd.DataFrame({'a': [1, 2], 'b': [3, 4]})
df2 = pd.DataFrame({'b': [5, 6], 'c': [7, 8]})

# Outer join (default): keeps all columns
print(pd.concat([df1, df2], ignore_index=True))
#      a  b    c
# 0  1.0  3  NaN
# 1  2.0  4  NaN
# 2  NaN  5  7.0
# 3  NaN  6  8.0

# Inner join: keeps only shared columns
print(pd.concat([df1, df2], join='inner', ignore_index=True))
#    b
# 0  3
# 1  4
# 2  5
# 3  6

Sammanfoga många filer i en loop

Ett vanligt mönster när flera filer läses in är att samla alla DataFrames i en lista och anropa pd.concat() en gång i slutet. Undvik att sammanfoga inuti en loop (t.ex. df = pd.concat([df, new_chunk])), eftersom det skapar en ny kopia av DataFrame vid varje iteration och leder till kvadratisk tidskomplexitet för stora samlingar.

import glob

# Efficient: collect first, concat once
files = glob.glob('data/sales_*.csv')
frames = [pd.read_csv(f) for f in files]
combined = pd.concat(frames, ignore_index=True)

# Inefficient (avoid):
# result = pd.DataFrame()
# for f in files:
#     result = pd.concat([result, pd.read_csv(f)])  # slow!

Sammanfoga Series

pd.concat() fungerar både med Series och DataFrames. Om Ni sammanfogar en lista med Series vertikalt får Ni en längre Series. Sammanfogning med axis=1 skapar en DataFrame där varje Series blir en kolumn. Series matchas utifrån sina index, så indexetiketterna måste överensstämma för en ren horisontell sammanfogning.

s1 = pd.Series([1, 2, 3], name='x')
s2 = pd.Series([4, 5, 6], name='y')

# Vertical: one long Series
print(pd.concat([s1, s2]))
# 0    1
# 1    2
# ...

# Horizontal: a DataFrame with two columns
print(pd.concat([s1, s2], axis=1))
#    x  y
# 0  1  4
# 1  2  5
# 2  3  6

Verifiera det sammanfogade resultatet

Efter sammanfogningen bör Ni alltid kontrollera att resultatet har förväntad form och inga oväntade NaN-värden. Ett snabbt rimlighetstest är att jämföra det kombinerade antalet rader med summan av de enskilda antalen och anropa isna().sum() för att upptäcka oavsiktligt saknade värden som uppstått genom felaktig kolumnmatchning. Dessa kontroller förhindrar att oupptäckta datakvalitetsproblem förs vidare i analysen.

combined = pd.concat([jan, feb], ignore_index=True)

# Sanity checks
assert len(combined) == len(jan) + len(feb), 'Row count mismatch'
print('Missing values per column:')
print(combined.isna().sum())
print('Shape:', combined.shape)

concat jämfört med append (föråldrad)

Äldre Pandas-kod kan använda df.append(other), som var en praktisk omslutning runt pd.concat(). Metoden blev föråldrad i Pandas 1.4 och togs bort i Pandas 2.0. Använd alltid pd.concat([df, other], ignore_index=True) i modern kod. Beteendet är identiskt, men pd.concat är tydligare och stöder sammanfogning av fler än två DataFrames samtidigt.

# Old (removed in Pandas 2.0):
# combined = jan.append(feb, ignore_index=True)

# Modern equivalent:
combined = pd.concat([jan, feb], ignore_index=True)
print(combined)

Praktiskt exempel: årlig försäljningsrapport

Här är ett realistiskt mönster: läs in månatliga DataFrames, lägg till en källbeteckning, sammanfoga dem och beräkna en helårssammanfattning. Parametern keys gör det enkelt att spåra varje rad tillbaka till dess månad, och ignore_index=True tillsammans med en månadskolumn ger en ren, platt DataFrame för gruppanalys.

months = ['jan', 'feb', 'mar']
frames = []
for m in months:
    df = pd.DataFrame({'product': ['A', 'B'], 'sales': [100, 200]})
    df['month'] = m
    frames.append(df)

yearly = pd.concat(frames, ignore_index=True)
print(yearly.groupby('month')['sales'].sum())

Snabbtest

Testa Er förståelse av pd.concat för att stapla DataFrames från den här lektionen.

Besvara frågan i den interaktiva lektionen

Sammanfattning av lektionen

I den här lektionen lärde du dig hur du staplar DataFrames vertikalt med pd.concat() och ignore_index=True, hur du spårar källor med hjälp av keys-parametern och hur join='inner' kontra 'outer' styr hanteringen av kolumner när scheman skiljer sig åt. Härnäst utforskar vi pd.merge() för SQL-liknande inner- och outer-joins på gemensamma nyckelkolumner.

Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 30
Lektioner: 120

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”pd.concat för att stapla DataFrames” gratis?

Ja – hela texten till ”pd.concat för att stapla DataFrames” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Pandas & NumPy Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Pandas & NumPy Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”pd.concat för att stapla DataFrames”?

Stapla DataFrames vertikalt eller horisontellt med pd.concat, justera efter index eller kolumner och hantera duplicerade index. Ni övar på Pandas & NumPy Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Pandas & NumPy Academy?

Du behöver inga förkunskaper. Utbildningen i Pandas & NumPy Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”pd.concat för att stapla DataFrames”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Pandas & NumPy Academy-lektionen?

Ja. Varje Pandas & NumPy Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Pandas & NumPy Academy