Pandas & NumPy Academy · leksjon

pd.concat for stabling av DataFrames

Stable DataFrames vertikalt eller horisontalt med pd.concat, juster etter indeks eller kolonner, og håndter duplikate indekser.

Leksjon 1 av 413 trinn

pd.concat for stabling av DataFrames er en gratis leksjon i Pandas & NumPy Academy på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Pandas & NumPy Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Pandas & NumPy Academy inneholder totalt 4 leksjoner.

Hvorfor slå sammen DataFrame-er?

I virkelige prosjekter kommer data sjelden i én enkelt fil. De kan ha månedlige salgsfiler, regionale spørreundersøkelseseksporter eller resultater fra databasespørringer fordelt på flere spørringer. Sammenslåing stabler disse separate DataFrame-ene i én kombinert tabell. Pandas tilbyr pd.concat() til dette formålet, og håndterer både vertikal (radvis) og horisontal (kolonnevis) stabling.

Grunnleggende vertikal sammenslåing

Den vanligste bruken av pd.concat() er å stable DataFrame-er vertikalt (legge til flere rader). Send inn en liste med DataFrame-er, så legger funksjonen dem etter hverandre. Begge DataFrame-ene må ha kompatible kolonner for å gi et ryddig resultat. Pandas justerer automatisk etter kolonnenavn og fyller manglende kolonner 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

Tilbakestille indeksen etter concat

Vær oppmerksom på at pd.concat() bevarer de opprinnelige indeksene fra hver DataFrame, noe som kan føre til dupliserte indeksverdier (som vist ovenfor med to rader på indeks 0 og indeks 1). Send inn ignore_index=True for å opprette en ny, fortløpende heltallsindeks i det kombinerte resultatet, noe som nesten alltid er det De ønsker.

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)

Spor kilden med keys

Når De slår sammen data fra flere kilder, kan De ha behov for å vite hvilken opprinnelig DataFrame hver rad kom fra. Send inn parameteren keys med en liste over etiketter. Pandas oppretter en MultiIndex der det ytre nivået identifiserer kilden. Deretter kan De bruke .loc['label'] for å hente rader fra en bestemt kilde.

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

Horisontal sammenslåing med axis=1

Send inn axis=1 for å slå sammen DataFrame-er side ved side (legge til flere kolonner). Pandas justerer etter radindeksen, så begge DataFrame-ene bør ha samme indeks for å gi et ryddig resultat. Hvis indeksene er ulike, fylles rader som ikke samsvarer med NaN. Dette er nyttig for å kombinere funksjoner som er beregnet fra samme datasett i separate trinn.

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

Håndtere kolonner som ikke samsvarer

Hvis DataFrame-ene som slås sammen har ulike kolonner, beholder Pandas alle kolonnene og fyller manglende verdier med NaN. Dette er standardoppførselen for join='outer'. Hvis De bare vil beholde kolonnene som finnes i alle DataFrame-ene, sender De inn join='inner', som fjerner kolonner som ikke finnes i hver eneste kilde.

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

Slå sammen mange filer i en løkke

Et typisk mønster ved lasting av flere filer er å samle alle DataFrame-ene i en liste og kalle pd.concat() én gang til slutt. Unngå å slå sammen data inne i en løkke (for eksempel df = pd.concat([df, new_chunk])), fordi dette oppretter en ny kopi av DataFrame-en i hver iterasjon og fører til kvadratisk tidskompleksitet for store samlinger.

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!

Slå sammen Series

pd.concat() fungerer med Series så vel som DataFrame-er. Når en liste med Series slås sammen vertikalt, får De en lengre Series. Sammenslåing med axis=1 produserer en DataFrame der hver Series blir en kolonne. Series-ene justeres etter indeksen, så indeksetikettene må samsvare for en ryddig horisontal sammenslåing.

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

Kontrollere det sammenslåtte resultatet

Etter en sammenslåing bør De alltid kontrollere at resultatet har forventet form og ingen uventede NaN-verdier. Et raskt kontrollmønster er å sammenligne det samlede antallet rader med summen av de individuelle antallene og kalle isna().sum() for å finne utilsiktede manglende verdier som skyldes feil justering av kolonner. Disse kontrollene hindrer at stille datakvalitetsproblemer videreføres 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 kontra append (utfaset)

Eldre Pandas-kode kan bruke df.append(other), som var en praktisk omslag rundt pd.concat(). Denne metoden ble foreldet i Pandas 1.4 og fjernet i Pandas 2.0. Bruk alltid pd.concat([df, other], ignore_index=True) i moderne kode. Oppførselen er identisk, men pd.concat er tydeligere og støtter sammenslåing av mer enn to DataFrame-er samtidig.

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

Praktisk eksempel: Årsrapport for salg

Her er et realistisk mønster: last inn månedlige DataFrame-er, legg til en kildeetikett, slå dem sammen og beregn et sammendrag for hele året. Parameteren keys gjør det enkelt å spore hver rad tilbake til måneden, og ignore_index=True kombinert med en månedskolonne gir en ren, flat DataFrame for gruppebasert analyse.

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())

Hurtigsjekk

Test forståelsen Deres av pd.concat for å stable DataFrame-er fra denne leksjonen.

Besvar den i den interaktive leksjonen

Oppsummering av leksjonen

I denne leksjonen lærte du: hvordan du stabler DataFrames vertikalt med pd.concat() og ignore_index=True, hvordan du holder oversikt over kilder ved hjelp av keys-parameteren, og hvordan join='inner' vs 'outer' styrer håndteringen av kolonner når skjemaene er forskjellige. Deretter utforsker vi pd.merge() for SQL-lignende inner- og outer-joins på felles nøkkelkolonner.

Gratis å komme i gang

Lær deg Python med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 30
Leksjoner: 120

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «pd.concat for stabling av DataFrames» gratis?

Ja – hele teksten i «pd.concat for stabling av DataFrames» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Pandas & NumPy Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Pandas & NumPy Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «pd.concat for stabling av DataFrames»?

Stable DataFrames vertikalt eller horisontalt med pd.concat, juster etter indeks eller kolonner, og håndter duplikate indekser. Du øver på Pandas & NumPy Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Pandas & NumPy Academy?

Ingen tidligere erfaring er nødvendig. Pandas & NumPy Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «pd.concat for stabling av DataFrames»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Pandas & NumPy Academy-leksjonen?

Ja. Alle Pandas & NumPy Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Pandas & NumPy Academy