Pandas & NumPy Academy · Lektion

Sortering efter indeks

Omarrangér rækker efter deres indekslabel med sort_index(), og forstå, hvornår et sorteret indeks forbedrer ydeevnen.

Lektion 2 af 413 trin

Sortering efter indeks er en gratis Pandas & NumPy Academy-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Pandas & NumPy Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Pandas & NumPy Academy-kurset indeholder 4 lektioner i alt.

Forstå DataFrame-indekset

Alle Pandas-DataFrames har et rækkeindeks — et sæt etiketter, der bruges til at identificere og få adgang til rækker. Som standard er dette et RangeIndex (0, 1, 2, …), men du kan angive en hvilken som helst kolonne (datoer, navne, ID'er) som indeks ved hjælp af set_index(). Når indekset har en betydning (f.eks. et DatetimeIndex eller et kunde-id), giver sortering efter det i stedet for efter en kolonneværdi et logisk organiseret resultat.

import pandas as pd

df = pd.DataFrame(
    {'value': [10, 20, 30]},
    index=['C', 'A', 'B']  # out-of-order alphabetic index
)
print(df)
#    value
# C     10
# A     20
# B     30

sort_index() — Stigende

DataFrame.sort_index() omarrangerer rækker efter deres indekslabel i stedet for efter kolonneværdier. Som standard sorteres der stigende — alfabetisk for tekstindekser, numerisk for heltalsindekser og kronologisk for DatetimeIndex. Dette er den almindelige måde at gendanne et datasæt til en naturlig rækkefølge efter blanding eller tilføjelse af poster ude af rækkefølge.

import pandas as pd

df = pd.DataFrame(
    {'temp': [22.5, 19.0, 25.1, 18.3]},
    index=pd.to_datetime(['2024-03-01', '2024-01-15', '2024-06-10', '2024-01-01'])
)

sorted_df = df.sort_index()
print(sorted_df)
#             temp
# 2024-01-01  18.3
# 2024-01-15  19.0
# 2024-03-01  22.5
# 2024-06-10  25.1

sort_index() — Faldende

Angiv ascending=False for at sortere indekset fra størst (eller senest) til mindst (eller tidligst). For et DatetimeIndex placerer dette de seneste observationer øverst, hvilket er det typiske layout for finansielle data, logfiler og hændelsesstrømme, hvor den seneste hændelse er mest relevant.

import pandas as pd

df = pd.DataFrame(
    {'price': [100, 110, 105, 115]},
    index=pd.to_datetime(['2024-01', '2024-02', '2024-03', '2024-04'])
)

# Most recent first
print(df.sort_index(ascending=False))
#             price
# 2024-04-30    115
# 2024-03-31    105
# 2024-02-29    110
# 2024-01-31    100

Sortering af kolonneetiketter med axis=1

Som standard sorterer sort_index() rækkeindekset (axis=0). Angiv axis=1 for i stedet at sortere kolonneetiketterne alfabetisk. Det er nyttigt til standardisering af brede DataFrames med mange kolonner, så kolonnerne vises i en forudsigelig alfabetisk rækkefølge, hvilket gør det nemmere visuelt at finde en kolonne eller sammenligne DataFrames.

import pandas as pd

df = pd.DataFrame({
    'zebra': [1], 'apple': [2], 'mango': [3], 'banana': [4]
})

print('Before:', df.columns.tolist())
# ['zebra', 'apple', 'mango', 'banana']

sorted_cols = df.sort_index(axis=1)
print('After:', sorted_cols.columns.tolist())
# ['apple', 'banana', 'mango', 'zebra']

Hvornår er et sorteret indeks hurtigere?

Pandas kan bruge binær søgning til opslag efter etiketter, når indekset er sorteret (monotont). Et sorteret indeks gør udsnit som .loc['2024-01':'2024-06'] til O(log n) i stedet for O(n). Metoden is_monotonic_increasing (eller is_monotonic_decreasing) returnerer en boolesk værdi, der angiver, om indekset allerede er sorteret. Det kan betale sig at sortere et stort indeks én gang, før du gentagne gange laver udsnit.

import pandas as pd
import numpy as np

idx = pd.to_datetime(['2024-03-01', '2024-01-15', '2024-06-10'])
df = pd.DataFrame({'v': [1, 2, 3]}, index=idx)

print('Sorted?', df.index.is_monotonic_increasing)  # False

df = df.sort_index()
print('Sorted?', df.index.is_monotonic_increasing)  # True

# Now slicing is efficient
print(df.loc['2024-01':'2024-03'])

sort_index() med MultiIndex

Når en DataFrame har et MultiIndex (hierarkisk rækkeindeks), sorterer sort_index() som standard alle niveauer i hierarkiet. Du kan begrænse sorteringen til bestemte niveauer med parameteren level. Et sorteret MultiIndex er nødvendigt for effektiv hierarkisk udvælgelse med .loc[(outer, inner), :].

import pandas as pd

arrays = [
    ['B', 'B', 'A', 'A'],
    ['two', 'one', 'two', 'one']
]
idx = pd.MultiIndex.from_arrays(arrays, names=['first', 'second'])
df = pd.DataFrame({'value': [10, 20, 30, 40]}, index=idx)

print(df.sort_index())
#               value
# first second
# A     one       40
#       two       30
# B     one       20
#       two       10

Sortering af kun ét niveau i et MultiIndex

Med et MultiIndex kan du have brug for kun at sortere efter det indre eller ydre niveau, mens rækkefølgen på det andet niveau bevares. Angiv level= til sort_index() — den accepterer et heltal (niveauets position), en tekststreng (niveauets navn) eller en liste. Det er nyttigt, når rækkefølgen på det ydre niveau allerede er korrekt, og du kun skal sortere inden for hver gruppe.

import pandas as pd

df = pd.DataFrame({
    'sales': [300, 100, 200, 400, 150, 250]
}, index=pd.MultiIndex.from_tuples([
    ('Eng', 'Dave'), ('Eng', 'Alice'), ('Eng', 'Bob'),
    ('HR', 'Zoe'), ('HR', 'Carol'), ('HR', 'Eve')
], names=['dept', 'name']))

# Sort only the 'name' level alphabetically within each dept
print(df.sort_index(level='name'))
#              sales
# dept name
# Eng  Alice    100
#      Bob      200
#      Dave     300
# HR   Carol    150
#      Eve      250
#      Zoe      400

Forskel på sort_index() og sort_values()

Det er vigtigt at skelne mellem de to sorteringsmetoder. sort_values(by='col') omarrangerer rækker baseret på dataværdierne i en kolonne. sort_index() omarrangerer rækker baseret på rækkens etiket (indekset), som måske svarer til en kolonne, men ikke nødvendigvis gør det. Når indekset er den primære identifikator (f.eks. et DatetimeIndex eller en meningsfuld strengnøgle), er sort_index() det rigtige valg.

import pandas as pd

df = pd.DataFrame(
    {'value': [30, 10, 20]},
    index=['C', 'A', 'B']
)

# sort_index: sorted by row label A, B, C
print(df.sort_index())
#    value
# A     10
# B     20
# C     30

# sort_values: sorted by data value 10, 20, 30
print(df.sort_values('value'))
#    value
# A     10
# B     20
# C     30
# (same here because values happen to match alphabetical label order!)

Gendannelse af den oprindelige rækkefølge efter operationer

Nogle operationer (blanding, tilfældig udvælgelse med df.sample(frac=1)) ændrer rækkefølgen af rækkerne. sort_index() er den enkle måde at gendanne den oprindelige rækkefølge på. Hvis den oprindelige rækkefølge var et RangeIndex (0, 1, 2, …), gendanner sort_index() den. Hvis det var en meningsfuld etiket, gendanner den etikettens naturlige rækkefølge.

import pandas as pd

df = pd.DataFrame({'x': [10, 20, 30, 40, 50]})

# Shuffle (random sample)
shuffled = df.sample(frac=1, random_state=42)
print('Shuffled index:', shuffled.index.tolist())
# e.g. [2, 4, 0, 1, 3]

# Restore original order by sorting the index
restored = shuffled.sort_index()
print('Restored index:', restored.index.tolist())
# [0, 1, 2, 3, 4]

sort_index() med na_position

Ligesom sort_values() understøtter sort_index() også na_position til at styre, hvor NaN-indeksetiketter vises. Det er relevant, når en DataFrame har et streng- eller datoindeks, der indeholder nogle NaN-etiketter (hvilket kan ske efter operationer, der indfører manglende indeksværdier). Standardværdien er 'last'.

import pandas as pd
import numpy as np

df = pd.DataFrame(
    {'v': [1, 2, 3, 4]},
    index=['B', None, 'A', 'C']
)

print(df.sort_index(na_position='last'))
#      v
# A    3
# B    1
# C    4
# NaN  2

Måling af ydelsesforbedringen

Du kan måle ydelsesforbedringen ved et sorteret indeks empirisk ved at bruge Pythons timeit til at sammenligne et udsnit på et usorteret og et sorteret DatetimeIndex. Den sorterede variant bruger binær søgning og er typisk 5-20 gange hurtigere for store DataFrames. Det viser, hvorfor sort_index() ikke bare er en kosmetisk operation — den har reelle konsekvenser for køretiden.

import pandas as pd
import numpy as np

np.random.seed(0)
random_dates = pd.to_datetime(
    pd.Timestamp('2020-01-01').value + np.random.randint(0, 1_000_000_000_000_000, size=100_000),
    unit='ns'
)
df = pd.DataFrame({'val': np.random.randn(100_000)}, index=random_dates)

# Without sort: O(n) scan
import timeit
t1 = timeit.timeit(lambda: df.loc['2022-01':'2022-06'], number=100)

df_sorted = df.sort_index()
t2 = timeit.timeit(lambda: df_sorted.loc['2022-01':'2022-06'], number=100)

print(f'Unsorted: {t1:.3f}s, Sorted: {t2:.3f}s, Speedup: {t1/t2:.1f}x')

Hurtigt tjek

Test din forståelse af sortering efter indeks i Pandas.

Besvar den i den interaktive lektion

Opsummering af lektionen

I denne lektion lærte du, at sort_index() omarrangerer rækker efter deres etiket (ikke kolonneværdier), at axis=1 sorterer kolonneetiketter alfabetisk, og at et sorteret indeks muliggør binær søgning, hvilket gør tidsbaserede udsnit meget hurtigere. For MultiIndex-DataFrames begrænser level= sorteringen til ét hierarkiniveau. Kontrollér altid is_monotonic_increasing, før du stoler på effektive opslag i udsnit. Næste emne er rangordning af værdier i en kolonne.

Gratis at komme i gang

Lær Python med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 30
Lektioner: 120

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Sortering efter indeks” gratis?

Ja — hele teksten til “Sortering efter indeks” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Pandas & NumPy Academy-kurset, skal du opgradere til CoddyKit PRO. Pandas & NumPy Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Sortering efter indeks”?

Omarrangér rækker efter deres indekslabel med sort_index(), og forstå, hvornår et sorteret indeks forbedrer ydeevnen. Du øver dig i Pandas & NumPy Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Pandas & NumPy Academy?

Der kræves ingen tidligere erfaring. Pandas & NumPy Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “Sortering efter indeks”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Pandas & NumPy Academy-lektion?

Ja. Alle Pandas & NumPy Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Pandas & NumPy Academy