Pandas & NumPy Academy · Lektion

Sortera efter kolumnvärden

Sortera en DataFrame efter en eller flera kolumner med sort_values(), styr stigande eller fallande ordning och hantera placeringen av NaN.

Lektion 1 av 413 steg

Sortera efter kolumnvärden ä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 sortering är viktig

Att sortera en DataFrame är viktigt för presentation (topplistor och top-N-rapporter), korrekthet (tidsserieoperationer kräver kronologisk ordning) och prestanda (binärsökning i ett sorterat index är O(log n) jämfört med O(n)). Pandas-metoden sort_values() är det huvudsakliga verktyget för att sortera efter kolumninnehåll och returnerar en ny DataFrame utan att ändra originalet.

import pandas as pd

df = pd.DataFrame({
    'name': ['Dave', 'Alice', 'Carol', 'Bob'],
    'score': [75, 92, 88, 65]
})

# Sort by score descending (highest first)
ranked = df.sort_values('score', ascending=False)
print(ranked)
#     name  score
# 1  Alice     92
# 2  Carol     88
# 0   Dave     75
# 3    Bob     65

sort_values() — grundläggande användning

DataFrame.sort_values(by) sorterar rader efter värdena i den angivna kolumnen. Argumentet by accepterar ett enskilt kolumnnamn (en sträng) eller en lista med kolumnnamn för sortering efter flera nycklar. Som standard sorteras värdena i stigande ordning (minst först). Ange ascending=False för fallande ordning.

import pandas as pd

df = pd.DataFrame({
    'product': ['B', 'A', 'C', 'A', 'B'],
    'price': [20, 10, 30, 15, 25]
})

# Ascending by price (default)
print(df.sort_values('price'))
#   product  price
# 1       A     10
# 3       A     15
# 0       B     20
# 4       B     25
# 2       C     30

Sortera efter flera kolumner

Om Ni skickar en lista med kolumnnamn till sort_values(by=) sorteras först den första kolumnen. Därefter används den andra kolumnen för att skilja lika värden åt, och så vidare. Parametern ascending kan också vara en lista med booleska värden i samma ordning som kolumnerna, vilket gör det möjligt att använda olika sorteringsriktningar för varje nyckel.

import pandas as pd

df = pd.DataFrame({
    'dept': ['HR', 'Eng', 'HR', 'Eng', 'Sales'],
    'salary': [50000, 90000, 60000, 80000, 70000],
    'name': ['Alice', 'Bob', 'Carol', 'Dave', 'Eve']
})

# Sort by dept A-Z, then by salary descending within each dept
sorted_df = df.sort_values(
    by=['dept', 'salary'],
    ascending=[True, False]
)
print(sorted_df)
#     dept  salary   name
# 1    Eng   90000    Bob
# 3    Eng   80000   Dave
# 2     HR   60000  Carol
# 0     HR   50000  Alice
# 4  Sales   70000    Eve

Placering av NaN med na_position

Som standard sorteras NaN-värden till slutet av resultatet, oavsett om ordningen är stigande eller fallande. Använd parametern na_position för att styra detta: 'last' (standard) eller 'first'. Det är viktigt att bestämma var NaN ska placeras i rangordnade tabeller – saknade värden kan betyda 'okänt' och bör tydligt skiljas från giltiga rangordnade poster.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Carol', 'Dave'],
    'score': [92, np.nan, 88, np.nan]
})

# NaN last (default)
print(df.sort_values('score', ascending=False, na_position='last'))
#     name  score
# 0  Alice   92.0
# 2  Carol   88.0
# 1    Bob    NaN
# 3   Dave    NaN

# NaN first
print(df.sort_values('score', na_position='first').head(2))

Stabil sortering och parametern kind=

Pandas använder som standard en stabil sortering (mergesort, som är O(n log n)) – när två rader har lika värden i sorteringsnyckeln bevaras deras ursprungliga inbördes ordning. Denna stabilitet är viktig när Ni först sorterar efter en primär nyckel och sedan efter en sekundär nyckel: den primära sorteringsordningen bevaras bland de poster som har samma värde på den sekundära nyckeln. Algoritmen kan ändras med kind='quicksort' (snabbare men instabil) eller kind='heapsort'.

import pandas as pd

df = pd.DataFrame({
    'group': ['A', 'B', 'A', 'B'],
    'value': [10, 10, 20, 20],
    'original_row': [0, 1, 2, 3]
})

# Stable sort: equal values keep original relative order
result = df.sort_values('value', kind='mergesort')
print(result)
#    group  value  original_row
# 0      A     10             0
# 1      B     10             1   <- row 0 before row 1 (stable)
# 2      A     20             2
# 3      B     20             3

inplace=True jämfört med omtilldelning

Precis som de flesta Pandas-metoder returnerar sort_values() som standard en ny DataFrame. Om Ni skickar inplace=True ändras DataFrame-objektet på plats och None returneras. Att använda inplace är i allmänhet avrått i modern Pandas eftersom det gör kod svårare att kedja och felsöka – det är enklare att alltid tilldela om: df = df.sort_values('col').

import pandas as pd

df = pd.DataFrame({'x': [3, 1, 4, 1, 5]})

# Preferred: reassign
df = df.sort_values('x')
print(df['x'].tolist())  # [1, 1, 3, 4, 5]

# Alternative: inplace (not recommended for pipelines)
df2 = pd.DataFrame({'x': [3, 1, 4]})
df2.sort_values('x', inplace=True)
print(df2['x'].tolist())  # [1, 3, 4]

Återställ index efter sortering

Efter sortering återspeglar radindexet de ursprungliga positionerna. I en tabell som sorterats fallande kan rad 0 nu ha index 4. Anropa .reset_index(drop=True) för att tilldela sekventiella index som börjar på 0. Detta är viktigt innan Ni använder .iloc[0] för att på ett tillförlitligt sätt hämta raden med högst rang eller innan Ni exporterar till en fil där luckor i indexet kan verka förvirrande.

import pandas as pd

df = pd.DataFrame({'score': [70, 90, 80]})
sorted_df = df.sort_values('score', ascending=False)
print(sorted_df)
#    score
# 1     90
# 2     80
# 0     70

# Clean sequential index
reset_df = sorted_df.reset_index(drop=True)
print(reset_df)
#    score
# 0     90
# 1     80
# 2     70

Hämta top-N med nlargest() och nsmallest()

För att välja de N översta eller nedersta raderna efter ett kolumnvärde är df.nlargest(n, 'col') och df.nsmallest(n, 'col') effektivare än att sortera hela DataFrame-objektet och sedan använda slicing. De använder en partiell sortering (heap-urval) som är O(n log k) i stället för O(n log n), vilket är viktigt för stora DataFrames.

import pandas as pd

df = pd.DataFrame({
    'product': ['A', 'B', 'C', 'D', 'E'],
    'revenue': [5000, 12000, 8000, 3000, 15000]
})

# Top 3 by revenue
top3 = df.nlargest(3, 'revenue')
print(top3)
#   product  revenue
# 4       E    15000
# 1       B    12000
# 2       C     8000

# Bottom 2 by revenue
bottom2 = df.nsmallest(2, 'revenue')
print(bottom2)

Sortera kategorikolumner efter kategoriordning

När en kolumn som innehåller en ordnad Categorical-dtype sorteras respekterar sort_values() kategoriordningen i stället för alfabetisk ordning. Detta är avgörande för korrekt ordning av prioritetsnivåer, allvarlighetsgrader eller storleksetiketter – 'Small' ska komma före 'Medium' och 'Large', inte i alfabetisk ordning där 'Large' kommer först.

import pandas as pd

df = pd.DataFrame({
    'size': pd.Categorical(
        ['Large', 'Small', 'Medium', 'Small', 'Large'],
        categories=['Small', 'Medium', 'Large'],
        ordered=True
    ),
    'count': [10, 5, 8, 3, 7]
})

print(df.sort_values('size'))
#      size  count
# 1   Small      5
# 3   Small      3
# 2  Medium      8
# 0   Large     10
# 4   Large      7

Kedja sortering med andra operationer

Eftersom sort_values() returnerar en DataFrame passar metoden naturligt in i metodkedjor. Ett typiskt mönster är: filtrera rader → aggregera → sortera → visa top-N. Kedjor håller transformationspipen linjär och lättläst.

import pandas as pd

df = pd.DataFrame({
    'dept': ['Eng', 'HR', 'Eng', 'Sales', 'HR', 'Eng'],
    'salary': [90000, 50000, 120000, 70000, 55000, 80000]
})

result = (
    df
    .groupby('dept')['salary'].mean()
    .reset_index()
    .sort_values('salary', ascending=False)
    .head(2)
)
print(result)
#    dept    salary
# 0   Eng  96666.67
# 2  Sales  70000.00

Praktiskt: rapport över de fem främsta produkterna

Här är ett praktiskt exempel från början till slut på hur Ni skapar en rapport över de fem främsta produkterna efter intäkt: läs in data, beräkna den totala intäkten per produkt, sortera fallande, ta de fem främsta, återställ indexet för att skapa ett rent rangnummer och lägg till en rankningskolumn för visning.

import pandas as pd

orders = pd.DataFrame({
    'product': ['A', 'B', 'A', 'C', 'B', 'D', 'E', 'A', 'C', 'E'],
    'revenue': [100, 200, 150, 80, 300, 60, 400, 120, 90, 350]
})

top5 = (
    orders
    .groupby('product')['revenue'].sum()
    .reset_index()
    .sort_values('revenue', ascending=False)
    .head(5)
    .reset_index(drop=True)
)
top5.index = top5.index + 1  # rank from 1
top5.index.name = 'rank'
print(top5)

Snabb kontroll

Testa Er förståelse av hur DataFrames sorteras efter kolumnvärden.

Besvara frågan i den interaktiva lektionen

Lektionssammanfattning

I den här lektionen lärde Ni Er att sort_values(by=) sorterar efter en eller flera kolumner, att ascending= kan vara en lista för olika riktningar per nyckel, att na_position='last' styr placeringen av NaN och att nlargest()/nsmallest() effektivt hämtar de N översta eller nedersta raderna utan att sortera hela DataFrame-objektet. Använd alltid reset_index() efter sortering för ett rent, sekventiellt resultat. Nästa steg är att sortera efter DataFrame-indexet.

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 ”Sortera efter kolumnvärden” gratis?

Ja – hela texten till ”Sortera efter kolumnvärden” 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 ”Sortera efter kolumnvärden”?

Sortera en DataFrame efter en eller flera kolumner med sort_values(), styr stigande eller fallande ordning och hantera placeringen av NaN. 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 ”Sortera efter kolumnvärden”?

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