Pandas & NumPy Academy · leksjon

Sortere etter indeks

Endre rekkefølgen på rader etter indeksetiketten med sort_index(), og forstå når en sortert indeks gir bedre ytelse.

Leksjon 2 av 413 trinn

Sortere etter indeks er en gratis leksjon i Pandas & NumPy Academy på CoddyKit. Dette er leksjon 2 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.

Forstå DataFrame-indeksen

Alle Pandas-DataFrames har en radindeks – et sett med etiketter som brukes til å identifisere og hente rader. Som standard er dette en RangeIndex (0, 1, 2, …), men De kan sette den til en hvilken som helst kolonne (datoer, navn eller ID-er) ved hjelp av set_index(). Når indeksen har en betydning (for eksempel en DatetimeIndex eller en kunde-ID), gir sortering etter den i stedet for etter en kolonneverdi et logisk organisert 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() ordner radene etter indeksens etikett i stedet for etter kolonneverdier. Som standard sorteres det stigende – alfabetisk for strengindekser, numerisk for heltallsindekser og kronologisk for DatetimeIndex. Dette er standardmåten å gjenopprette en naturlig rekkefølge i et datasett etter stokking eller etter at poster er lagt til i feil rekkefø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() – synkende

Oppgi ascending=False for å sortere indeksen fra størst (eller nyest) til minst (eller eldst). For en DatetimeIndex plasserer dette de nyeste observasjonene øverst, noe som er vanlig i finansdata, loggfiler og hendelsesstrømmer der den siste hendelsen 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 av kolonneetiketter med axis=1

Som standard sorterer sort_index() radindeksen (axis=0). Oppgi axis=1 for å sortere kolonneetikettene alfabetisk i stedet. Dette er nyttig for å standardisere brede DataFrames med mange kolonner, slik at kolonnene vises i en forutsigbar alfabetisk rekkefølge. Det blir dermed enklere å finne en kolonne visuelt 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']

Når er en sortert indeks raskere?

Pandas kan bruke binærsøk ved oppslag på etiketter når indeksen er sortert (monoton). En sortert indeks gjør utsnitt 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 boolsk verdi som angir om indeksen allerede er sortert. Det er en lønnsom engangskostnad å sortere en stor indeks før De gjør gjentatte utsnitt.

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 en MultiIndex (hierarkisk radindeks), sorterer sort_index() som standard alle nivåene i hierarkiet. De kan begrense sorteringen til bestemte nivåer med parameteren level. En sortert MultiIndex er nødvendig for effektivt hierarkisk utsnitt 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 av bare ett MultiIndex-nivå

Med en MultiIndex kan De ønske å sortere bare etter det indre eller ytre nivået, samtidig som rekkefølgen på det andre nivået beholdes. Oppgi level= til sort_index() – parameteren kan ta imot et heltall (nivåets posisjon), en streng (nivåets navn) eller en liste. Dette er nyttig når rekkefølgen på det ytre nivået allerede er riktig, og De bare trenger å sortere innenfor 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

Forskjellen mellom sort_index() og sort_values()

Det er viktig å skille mellom de to sorteringsmetodene. sort_values(by='col') omorganiserer rader basert på dataverdiene i en kolonne. sort_index() omorganiserer rader basert på radetiketten (indeksen), som kan samsvare med en kolonne, men ikke nødvendigvis gjør det. Når indeksen er den primære identifikatoren (for eksempel en DatetimeIndex eller en meningsfull tekstnøkkel), er sort_index() det riktige valget.

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

Gjenopprette den opprinnelige rekkefølgen etter operasjoner

Noen operasjoner (blant annet stokking og tilfeldig utvalg med df.sample(frac=1)) endrer rekkefølgen på radene. sort_index() er den ryddige måten å gjenopprette den opprinnelige sekvensielle rekkefølgen på. Hvis den opprinnelige rekkefølgen var en RangeIndex (0, 1, 2, …), gjenoppretter sort_index() den. Hvis den var basert på meningsfulle etiketter, gjenoppretter metoden etikettenes naturlige rekkefø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

På samme måte som sort_values() støtter sort_index() også na_position, slik at De kan styre hvor NaN-indeksetiketter skal plasseres. Dette er relevant når en DataFrame har en tekst- eller datindeks som inneholder enkelte NaN-etiketter (noe som kan skje etter operasjoner som introduserer manglende indeksverdier). Standardverdien 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 av ytelsesforbedring

De kan måle ytelsesgevinsten ved en sortert indeks empirisk ved å bruke Pythons timeit til å sammenligne et utsnitt på en usortert og en sortert DatetimeIndex. Det sorterte tilfellet bruker binærsøk og er vanligvis 5–20 ganger raskere for store DataFrames. Dette viser hvorfor sort_index() ikke bare er en kosmetisk operasjon – den har reelle konsekvenser for kjø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')

Hurtigsjekk

Test forståelsen Deres av sortering etter indeks i Pandas.

Besvar den i den interaktive leksjonen

Oppsummering av leksjonen

I denne leksjonen lærte De at sort_index() omorganiserer rader etter etiketten (ikke kolonneverdiene), at axis=1 sorterer kolonneetiketter alfabetisk, og at en sortert indeks muliggjør binærsøk, slik at tidsbaserte utsnitt blir mye raskere. For DataFrames med MultiIndex begrenser level= sorteringen til ett hierarkinivå. Kontroller alltid is_monotonic_increasing før De baserer Dem på effektive oppslag i utsnitt. Neste tema er rangering av verdier i en kolonne.

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 «Sortere etter indeks» gratis?

Ja – hele teksten i «Sortere etter indeks» 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 «Sortere etter indeks»?

Endre rekkefølgen på rader etter indeksetiketten med sort_index(), og forstå når en sortert indeks gir bedre ytelse. 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 2 av 4.

Hvor lang tid tar leksjonen «Sortere etter indeks»?

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