Pandas & NumPy Academy · Lektion

Välja kolumner och rader

Välj en eller flera kolumner med hakparentesnotation och hämta rader efter etikett och position med .loc och .iloc.

Lektion 2 av 413 steg

Välja kolumner och rader är en gratis lektion i Pandas & NumPy Academy på CoddyKit. Detta är lektion 2 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.

Välj en enskild kolumn

Åtkomst till en enskild kolumn via namnet får du med hakparenteser df['col'], vilket returnerar en Series. Du kan också använda punktnotationen df.col när kolumnnamnet är en giltig Python-identifierare utan blanksteg. Hakparenteser är alltid säkra; punktnotationen fungerar inte för namn som krockar med DataFrame-metoder, till exempel count eller mean.

import pandas as pd

df = pd.DataFrame({'name': ['Alice', 'Bob'], 'score': [90, 75]})
print(df['name'])     # Series
print(type(df['name']))  # pandas.core.series.Series

Välj flera kolumner

Om du vill välja flera kolumner skickar du in en lista med kolumnnamn inom hakparenteserna: df[['col1', 'col2']]. Lägg märke till de dubbla hakparenteserna — det yttre paret är indexeringsoperatorn och det inre paret skapar en Python-lista. Resultatet är en DataFrame, inte en Series. Detta används ofta för att ta fram en feature-matris för maskininlärning.

import pandas as pd

df = pd.DataFrame({'a': [1,2], 'b': [3,4], 'c': [5,6]})
subset = df[['a', 'c']]
print(type(subset))      # pandas.core.frame.DataFrame
print(subset)

.loc för val av rader och kolumner

df.loc[row_label, col_label] väljer data efter etikett. Ange en enskild etikett, en lista med etiketter eller ett intervall för både rader och kolumner. df.loc[:, 'score'] väljer alla rader i kolumnen 'score'. df.loc['r1':'r3', ['a', 'b']] väljer raderna r1 till r3 (inklusive) för kolumnerna a och b.

import pandas as pd

df = pd.DataFrame({'x': [10,20,30], 'y': [40,50,60]},
                  index=['r1', 'r2', 'r3'])
print(df.loc['r2', 'x'])       # 20
print(df.loc['r1':'r2', 'y'])  # r1:40  r2:50

.iloc för positionsbaserat urval

df.iloc[row_pos, col_pos] väljer efter heltalsposition och ignorerar etiketter. Båda argumenten följer Pythons intervallkonventioner, där slutpositionen inte inkluderas. df.iloc[:, 0] väljer den första kolumnen som en Series. df.iloc[0:2, 1:3] väljer en rektangulär under-DataFrame på 2×2 från det övre vänstra hörnet.

import pandas as pd

df = pd.DataFrame({'a': [1,2,3], 'b': [4,5,6], 'c': [7,8,9]})
print(df.iloc[1, 2])        # 8  -- row 1, col 2
print(df.iloc[0:2, 0:2])   # top-left 2x2 sub-table

Booleskt radurval

Skicka en boolesk Series (med samma index som DataFrame) till .loc för att filtrera rader. Skapa den booleska Series utifrån ett villkor på en kolumn. Du kan kombinera villkor med & och |. Detta är standardmönstret för filtrering i Pandas dataanalys och är mycket mer uttrycksfullt än SQL:s WHERE-satser vid komplexa villkor över flera kolumner.

import pandas as pd

df = pd.DataFrame({'name': ['A','B','C','D'], 'score': [80,55,92,71]})
high = df.loc[df['score'] >= 70]
print(high)
#   name  score
# 0    A     80
# 2    C     92
# 3    D     71

Sammansatta filtreringsvillkor

Flera villkor måste var och en omges av parenteser och kombineras med & (AND) eller | (OR). Om du använder Pythons nyckelord and/or på Series uppstår ett fel. Om du vill negera ett villkor använder du ~ (tilde) i stället för not. Testa alltid villkoren var för sig innan du kombinerar dem, så att du kan hitta orsaken till oväntade resultat.

import pandas as pd

df = pd.DataFrame({'name': ['A','B','C','D'],
                   'score': [80, 55, 92, 71],
                   'dept': ['Eng', 'HR', 'Eng', 'HR']})
filtered = df.loc[(df['score'] >= 70) & (df['dept'] == 'Eng')]
print(filtered)

Välj rader efter heltalsposition

df.iloc[n] returnerar den n:te raden som en Series. df.iloc[n:m] returnerar raderna n till m-1 som en DataFrame. df.iloc[[0, 2, 4]] väljer specifika rader efter position med avancerad indexering. Detta motsvarar radurval i NumPy-arrayer och används ofta vid uppdelning i tränings- och testdata innan maskininlärningsmodeller tillämpas.

import pandas as pd

df = pd.DataFrame({'a': range(5), 'b': range(5, 10)})
print(df.iloc[0])         # first row as Series
print(df.iloc[1:3])       # rows 1 and 2 as DataFrame
print(df.iloc[[0, 4]])    # first and last row

Kombinera rad- och kolumnurval

Både .loc och .iloc accepterar två argument: df.loc[row_selector, col_selector]. Det gör det möjligt att välja ett exakt rektangulärt område i ett enda uttryck. Ett ensamt kolon : väljer alla rader eller alla kolumner. Detta mönster är viktigt när du vill ta fram en feature-matris med specifika kolumner för endast träningsraderna i ett dataset.

import pandas as pd

df = pd.DataFrame({'x': [1,2,3], 'y': [4,5,6], 'z': [7,8,9]})
# Filter rows where x > 1, keep columns y and z
result = df.loc[df['x'] > 1, ['y', 'z']]
print(result)
#    y  z
# 1  5  8
# 2  6  9

Välj en enskild rad med .loc

När du skickar en enskild skalär etikett till df.loc[label] blir resultatet en Series där indexet består av kolumnnamnen. Detta är användbart när du vill granska en specifik post. Om du i stället vill få en DataFrame med en enda rad omsluter du etiketten i en lista: df.loc[[label]]. Skillnaden är viktig när du skickar resultat till funktioner som förväntar sig en DataFrame.

import pandas as pd

df = pd.DataFrame({'name': ['A','B'], 'score': [80, 90]},
                  index=['r1', 'r2'])
print(type(df.loc['r1']))    # Series
print(type(df.loc[['r1']])) # DataFrame

at och iat för snabb åtkomst till skalärer

df.at[row_label, col_name] och df.iat[row_pos, col_pos] hämtar eller anger ett enda skalärt värde med mindre overhead än .loc/.iloc. De är utformade för loopar som uppdaterar enskilda celler. Föredra alltid vektoriserade operationer framför cellvisa uppdateringar i produktionskod, men använd at/iat när du faktiskt behöver iterera.

import pandas as pd

df = pd.DataFrame({'x': [1, 2, 3], 'y': [4, 5, 6]},
                  index=['a', 'b', 'c'])
print(df.at['b', 'y'])    # 5
print(df.iat[2, 0])       # 3

Varning för kedjad indexering

Kedjad indexering som df['col'][condition] eller df[mask]['col'] = val kan ge en SettingWithCopyWarning eftersom Pandas kan arbeta med en kopia i stället för originalet. Använd alltid ett enda .loc-uttryck vid ändringar: df.loc[mask, 'col'] = val. Detta är det korrekta mönstret som inte ger varningar.

import pandas as pd

df = pd.DataFrame({'score': [80, 55, 92]})
# WRONG - may not modify original:
# df[df['score'] > 60]['score'] = 100

# CORRECT:
df.loc[df['score'] > 60, 'score'] = 100
print(df)

Snabbtest

Testa dina kunskaper om hur man väljer kolumner och rader från den här lektionen.

Besvara frågan i den interaktiva lektionen

Lektionssammanfattning

I den här lektionen lärde du dig att: .loc väljer rader och kolumner efter etikett med inkluderande slut i intervall, .iloc väljer efter heltalsposition med exkluderande slut, precis som Pythons intervall och booleska villkor som tillämpas via .loc filtrerar rader utan problemet med SettingWithCopyWarning som kedjad indexering kan orsaka. Nästa steg är att lägga till nya beräknade kolumner, byta namn på befintliga och ta bort oönskade kolumner med drop().

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 ”Välja kolumner och rader” gratis?

Ja – hela texten till ”Välja kolumner och rader” 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 ”Välja kolumner och rader”?

Välj en eller flera kolumner med hakparentesnotation och hämta rader efter etikett och position med .loc och .iloc. 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 2 av 4.

Hur lång tid tar lektionen ”Välja kolumner och rader”?

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