Skip to content

Pandas Sort Values: Vollständige Anleitung zum Sortieren von DataFrames in Python

Soren Atelier
Name
Soren Atelier

Updated on

Unsortierte Daten sind schwer zu analysieren. Sie durchsuchen Tausende von Zeilen, um die höchsten Umsätze, die neuesten Daten oder die niedrigsten Fehlerquoten zu finden -- und übersehen Muster, die offensichtlich wären, wenn die Daten sortiert wären. Das Sortieren einer Python-Liste funktioniert für einfache Fälle, aber DataFrames haben mehrere Spalten, gemischte Typen und fehlende Werte, die Listen nicht verarbeiten können.

Pandas sort_values() sortiert jeden DataFrame nach einer oder mehreren Spalten, mit voller Kontrolle über aufsteigende/absteigende Reihenfolge, Null-Platzierung und Stabilität. Dieser Leitfaden behandelt jedes Sortiermuster, das Ihnen in der realen Datenarbeit begegnet.

📚

    Grundlegendes Sortieren mit sort_values()

    Nach einer Spalte sortieren

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve'],
    'score': [85, 92, 78, 95, 88],
    'age': [25, 30, 22, 28, 35]
})
 
# Nach Score sortieren (standardmäßig aufsteigend)
sorted_df = df.sort_values('score')
print(sorted_df)
#       name  score  age
# 2  Charlie     78   22
# 0    Alice     85   25
# 4      Eve     88   35
# 1      Bob     92   30
# 3    Diana     95   28

    Absteigend sortieren

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve'],
    'score': [85, 92, 78, 95, 88],
    'age': [25, 30, 22, 28, 35]
})
 
# Höchste Punktzahlen zuerst
sorted_df = df.sort_values('score', ascending=False)
print(sorted_df)
#       name  score  age
# 3    Diana     95   28
# 1      Bob     92   30
# 4      Eve     88   35
# 0    Alice     85   25
# 2  Charlie     78   22

    In-Place sortieren

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie'],
    'score': [85, 92, 78]
})
 
# df direkt ändern (keine Kopie erstellt)
df.sort_values('score', inplace=True)
print(df)
#       name  score
# 2  Charlie     78
# 0    Alice     85
# 1      Bob     92

    Mehrspaltige Sortierung

    Nach mehreren Spalten sortieren

    import pandas as pd
 
df = pd.DataFrame({
    'department': ['Sales', 'Engineering', 'Sales', 'Engineering', 'Sales'],
    'name': ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve'],
    'salary': [70000, 85000, 65000, 90000, 70000]
})
 
# Zuerst nach Abteilung, dann nach Gehalt innerhalb jeder Abteilung
sorted_df = df.sort_values(['department', 'salary'])
print(sorted_df)
#     department     name  salary
# 1  Engineering      Bob   85000
# 3  Engineering    Diana   90000
# 2        Sales  Charlie   65000
# 0        Sales    Alice   70000
# 4        Sales      Eve   70000

    Gemischt aufsteigend/absteigend

    import pandas as pd
 
df = pd.DataFrame({
    'department': ['Sales', 'Engineering', 'Sales', 'Engineering', 'Sales'],
    'name': ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve'],
    'salary': [70000, 85000, 65000, 90000, 70000]
})
 
# Abteilung aufsteigend, Gehalt absteigend
sorted_df = df.sort_values(
    ['department', 'salary'],
    ascending=[True, False]
)
print(sorted_df)
#     department     name  salary
# 3  Engineering    Diana   90000
# 1  Engineering      Bob   85000
# 0        Sales    Alice   70000
# 4        Sales      Eve   70000
# 2        Sales  Charlie   65000

    Umgang mit fehlenden Werten (NaN)

    Standardmäßig werden NaN-Werte unabhängig von der Sortierreihenfolge ans Ende gesetzt. Verwenden Sie na_position zur Steuerung:

    import pandas as pd
import numpy as np
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'Diana'],
    'score': [85, np.nan, 78, np.nan]
})
 
# NaN am Ende (Standard)
print(df.sort_values('score'))
#       name  score
# 2  Charlie   78.0
# 0    Alice   85.0
# 1      Bob    NaN
# 3    Diana    NaN
 
# NaN am Anfang
print(df.sort_values('score', na_position='first'))
#       name  score
# 1      Bob    NaN
# 3    Diana    NaN
# 2  Charlie   78.0
# 0    Alice   85.0

    Nach Index sortieren mit sort_index()

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie'],
    'score': [85, 92, 78]
}, index=[2, 0, 1])
 
# Nach Index sortieren
print(df.sort_index())
#      name  score
# 0     Bob     92
# 1  Charlie    78
# 2   Alice     85
 
# Nach Spaltennamen sortieren (axis=1)
df2 = pd.DataFrame({
    'c': [1, 2], 'a': [3, 4], 'b': [5, 6]
})
print(df2.sort_index(axis=1))
#    a  b  c
# 0  3  5  1
# 1  4  6  2

    Index nach dem Sortieren zurücksetzen

    Nach dem Sortieren bleibt der ursprüngliche Index erhalten. Für einen sauberen fortlaufenden Index:

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie'],
    'score': [85, 92, 78]
})
 
sorted_df = df.sort_values('score').reset_index(drop=True)
print(sorted_df)
#       name  score
# 0  Charlie     78
# 1    Alice     85
# 2      Bob     92

    Verwenden Sie drop=True, um den alten Index zu verwerfen. Ohne diesen Parameter wird der alte Index zu einer Spalte.

    Benutzerdefinierte Sortierreihenfolge

    Verwendung von Kategorietypen

    import pandas as pd
 
df = pd.DataFrame({
    'priority': ['Medium', 'High', 'Low', 'High', 'Medium'],
    'task': ['Task A', 'Task B', 'Task C', 'Task D', 'Task E']
})
 
# Benutzerdefinierte Reihenfolge definieren
priority_order = pd.CategoricalDtype(['Low', 'Medium', 'High'], ordered=True)
df['priority'] = df['priority'].astype(priority_order)
 
sorted_df = df.sort_values('priority')
print(sorted_df)
#   priority    task
# 2      Low  Task C
# 0   Medium  Task A
# 4   Medium  Task E
# 1     High  Task B
# 3     High  Task D

    Verwendung des key-Parameters

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['alice', 'Bob', 'CHARLIE', 'diana'],
    'score': [85, 92, 78, 95]
})
 
# Groß-/Kleinschreibung ignorieren
sorted_df = df.sort_values('name', key=lambda x: x.str.lower())
print(sorted_df)
#       name  score
# 0    alice     85
# 1      Bob     92
# 2  CHARLIE     78
# 3    diana     95

    Methodenvergleich

    MethodeZweckÄndert Original?Rückgabe
    sort_values(col)Nach Spaltenwerten sortierenNein (außer inplace=True)Sortierter DataFrame
    sort_values([col1, col2])Nach mehreren Spalten sortierenNein (außer inplace=True)Sortierter DataFrame
    sort_index()Nach Zeilenindex sortierenNein (außer inplace=True)Sortierter DataFrame
    nsmallest(n, col)n kleinste Werte abrufenNeinDataFrame-Teilmenge
    nlargest(n, col)n größte Werte abrufenNeinDataFrame-Teilmenge
    rank()Werten Ränge zuweisenNeinSeries mit Rängen

    Leistungstipps

    nlargest() und nsmallest() für Top-N

    Wenn Sie nur die oberen oder unteren N Zeilen benötigen, sind nlargest() und nsmallest() schneller als das Sortieren des gesamten DataFrames:

    import pandas as pd
import numpy as np
 
# Großer DataFrame
df = pd.DataFrame({
    'id': range(1_000_000),
    'value': np.random.randn(1_000_000)
})
 
# Schneller: nur Top 10 finden
top_10 = df.nlargest(10, 'value')
 
# Langsamer: alles sortieren, dann ausschneiden
top_10_slow = df.sort_values('value', ascending=False).head(10)

    Stabile vs. instabile Sortierung

    import pandas as pd
 
df = pd.DataFrame({
    'group': ['A', 'B', 'A', 'B'],
    'value': [1, 1, 2, 2],
    'order': [1, 2, 3, 4]
})
 
# Stabile Sortierung (Standard) behält die ursprüngliche Reihenfolge bei Gleichheit bei
stable = df.sort_values('value', kind='mergesort')  # Standard
 
# Instabile Sortierung (schneller bei großen Datensätzen)
unstable = df.sort_values('value', kind='quicksort')

    Praktische Beispiele

    Datumsangaben sortieren

    import pandas as pd
 
df = pd.DataFrame({
    'event': ['Launch', 'Meeting', 'Deadline', 'Review'],
    'date': pd.to_datetime(['2026-03-15', '2026-01-10', '2026-02-28', '2026-01-05'])
})
 
# Chronologische Reihenfolge
print(df.sort_values('date'))
#      event       date
# 3   Review 2026-01-05
# 1  Meeting 2026-01-10
# 2 Deadline 2026-02-28
# 0   Launch 2026-03-15

    Sortieren mit GroupBy

    import pandas as pd
 
df = pd.DataFrame({
    'store': ['A', 'A', 'B', 'B', 'A', 'B'],
    'product': ['X', 'Y', 'X', 'Y', 'Z', 'Z'],
    'revenue': [100, 250, 150, 300, 200, 175]
})
 
# Umsatzstärkstes Produkt pro Geschäft
top_per_store = (df.sort_values('revenue', ascending=False)
                   .groupby('store')
                   .head(1))
print(top_per_store)
#   store product  revenue
# 3     B       Y      300
# 1     A       Y      250

    Sortierte Daten visuell erkunden

    Nachdem Sie Ihren DataFrame sortiert haben, um Muster zu finden, können Sie mit PyGWalker (opens in a new tab) die gleichen Daten über interaktive Drag-and-Drop-Diagramme in Jupyter erkunden -- ohne zusätzlichen Code:

    import pygwalker as pyg
 
walker = pyg.walk(sorted_df)

    Häufig gestellte Fragen

    Wie sortiere ich einen DataFrame nach einer Spalte in pandas?

    Verwenden Sie df.sort_values('column_name') für aufsteigende oder df.sort_values('column_name', ascending=False) für absteigende Sortierung. Für mehrere Spalten übergeben Sie eine Liste: df.sort_values(['col1', 'col2']).

    Wie sortiere ich nach mehreren Spalten mit verschiedenen Reihenfolgen?

    Übergeben Sie eine Liste von Booleans an ascending: df.sort_values(['col1', 'col2'], ascending=[True, False]). Dies sortiert col1 aufsteigend und col2 absteigend.

    Wohin kommen NaN-Werte beim Sortieren?

    Standardmäßig werden NaN-Werte unabhängig von der Sortierrichtung ans Ende gesetzt. Verwenden Sie na_position='first', um sie an den Anfang zu setzen: df.sort_values('col', na_position='first').

    Was ist der Unterschied zwischen sort_values und sort_index?

    sort_values() sortiert nach Spaltenwerten. sort_index() sortiert nach dem Zeilenindex (oder Spaltenindex mit axis=1). Verwenden Sie sort_values zum Datensortieren und sort_index, wenn Zeilen nach ihren Indexbezeichnungen geordnet sein müssen.

    Wie sortiere ich einen DataFrame in-place ohne eine Kopie zu erstellen?

    Übergeben Sie inplace=True: df.sort_values('col', inplace=True). Dies ändert den ursprünglichen DataFrame und gibt None zurück. Der moderne pandas-Stil bevorzugt jedoch die Neuzuweisung: df = df.sort_values('col').

    Fazit

    sort_values() ist das primäre Werkzeug zum Sortieren von DataFrames in pandas. Verwenden Sie einen einzelnen Spaltennamen für einfache Sortierungen, eine Liste für mehrspaltige Sortierungen und den ascending-Parameter zur Steuerung der Richtung. Behandeln Sie fehlende Werte mit na_position, verwenden Sie nlargest()/nsmallest() für Top-N-Abfragen und CategoricalDtype für benutzerdefinierte Reihenfolgen. Denken Sie daran, dass das Sortieren standardmäßig einen neuen DataFrame zurückgibt -- verwenden Sie reset_index(drop=True), wenn Sie danach einen sauberen fortlaufenden Index benötigen.

    📚