Sorting: sort_values, sort_index, nlargest

"Orange Cap leaderboard — highest runs first." "Sort by team, and inside each team by runs." "Top 3 wicket-takers." Sorting turns a table into an answer. Pandas sorts by values (sort_values), by labels (sort_index), and has shortcuts for top/bottom-N (nlargest, nsmallest).

Definition

DataFrame.sort_values(by) returns a new DataFrame with rows reordered by the values of one or more columns. DataFrame.sort_index() reorders rows (or columns) by their labels. nlargest(n, columns) / nsmallest(n, columns) return the n rows with the largest / smallest values directly.

• Reordered — rows move together with their index labels; nothing inside a row changes. After sorting, labels look jumbled (0, 6, 1…) — that's expected.
• One or more columns — with several columns, the first is the main sort key, the next breaks ties, and so on (like sorting a points table by points, then net run rate).
• New DataFrame — the original order is untouched unless you reassign.

Syntax

df.sort_values(by, ascending=True, na_position="last", ignore_index=False, key=None)
df.sort_index(axis=0, ascending=True)
df.nlargest(n, columns, keep="first")
df.nsmallest(n, columns, keep="first")

Example — sort by one column

print(players.sort_values("runs"))
print(players.sort_values("runs", ascending=False)[["player", "runs"]])

            player team         role  runs  wickets  strike_rate
3   Jasprit Bumrah   MI       Bowler     8       20         80.0
7      Rashid Khan   GT       Bowler   102       10        120.0
2         MS Dhoni  CSK       Keeper   161        0        220.5
4    Hardik Pandya   MI  All-rounder   216       11        143.0
5  Ravindra Jadeja  CSK  All-rounder   267        8        157.1
1     Rohit Sharma   MI       Batter   417        0        150.0
6     Shubman Gill   GT       Batter   426        0        147.4
0      Virat Kohli  RCB       Batter   741        0        154.7
            player  runs
0      Virat Kohli   741
6     Shubman Gill   426
1     Rohit Sharma   417
5  Ravindra Jadeja   267
4    Hardik Pandya   216
2         MS Dhoni   161
7      Rashid Khan   102
3   Jasprit Bumrah     8

How it works: the default is ascending (smallest first). ascending=False gives the leaderboard order. Each row kept its original label — Kohli is still label 0 — which is why the index on the left looks shuffled.

Example — sort by several columns

print(players.sort_values(["team", "runs"], ascending=[True, False])[["player", "team", "runs"]])

            player team  runs
5  Ravindra Jadeja  CSK   267
2         MS Dhoni  CSK   161
6     Shubman Gill   GT   426
7      Rashid Khan   GT   102
1     Rohit Sharma   MI   417
4    Hardik Pandya   MI   216
3   Jasprit Bumrah   MI     8
0      Virat Kohli  RCB   741

How it works: rows are first ordered by team A→Z (CSK, GT, MI, RCB). Within each team, they're ordered by runs — and because ascending=[True, False], the second key is descending, so each team's top scorer comes first. The ascending list must have one entry per column in by.

Example — missing values, ignore_index and sort_index

import numpy as np

d = pd.DataFrame({"player": ["A", "B", "C", "D"], "runs": [50, np.nan, 20, 80]})
print(d.sort_values("runs"))
print(d.sort_values("runs", na_position="first"))

print(players.sort_values("runs", ascending=False, ignore_index=True)[["player", "runs"]].head(3))
s = players.sort_values("runs", ascending=False)
print(s.sort_index()[["player", "runs"]].head(3))

  player  runs
2      C  20.0
0      A  50.0
3      D  80.0
1      B   NaN
  player  runs
1      B   NaN
2      C  20.0
0      A  50.0
3      D  80.0
         player  runs
0   Virat Kohli   741
1  Shubman Gill   426
2  Rohit Sharma   417
         player  runs
0   Virat Kohli   741
1  Rohit Sharma   417
2      MS Dhoni   161

How it works: NaN always goes to the end by default — whether ascending or descending; na_position="first" moves it to the top. ignore_index=True sorts and renumbers in one step (same as adding .reset_index(drop=True)). sort_index() sorts by the labels, so it restores the original order of a sorted table. On a named index (set_index("player")) it sorts alphabetically by name, and sort_index(axis=1) sorts the columns by name.

Example — nlargest and nsmallest

print(players.nlargest(3, "runs")[["player", "runs"]])
print(players.nsmallest(2, "strike_rate")[["player", "strike_rate"]])
print(players.nsmallest(3, "wickets")[["player", "wickets"]])
print(players.nsmallest(3, "wickets", keep="all")[["player", "wickets"]])

         player  runs
0   Virat Kohli   741
6  Shubman Gill   426
1  Rohit Sharma   417
           player  strike_rate
3  Jasprit Bumrah         80.0
7     Rashid Khan        120.0
         player  wickets
0   Virat Kohli        0
1  Rohit Sharma        0
2      MS Dhoni        0
         player  wickets
0   Virat Kohli        0
1  Rohit Sharma        0
2      MS Dhoni        0
6  Shubman Gill        0

How it works: nlargest(3, "runs") = sort_values("runs", ascending=False).head(3), but clearer and faster on big data (it doesn't sort everything). Ties: four players have 0 wickets. With the default keep="first", only the first 3 are returned; keep="all" keeps every tied row, so you get 4. nlargest works only on numeric columns — for text, use sort_values.

Comparison — which sorting tool?

Common mistakes

• ❌ players.sort_values("runs") and then printing players — unchanged! ✅ Reassign: players = players.sort_values("runs"). (sort_values(..., inplace=True) returns None and is discouraged.)
• ❌ sort_values(["team", "runs"], ascending=False) when only runs should be descending. ✅ ascending=[True, False].
• ❌ sort_values(by="Runs") → KeyError: 'Runs'. ✅ Exact, case-sensitive column name.
• ❌ Using loc[0:3] to take the top 3 after sorting. ✅ Labels moved with the rows — use head(3), iloc[0:3] or nlargest(3, ...).
• ❌ Expecting keep="first" in nlargest to show all tied players. ✅ Use keep="all".

Interview tip

Q: How do you sort a DataFrame by team ascending and runs descending? A: df.sort_values(["team", "runs"], ascending=[True, False]). The by list sets the priority (team first, runs breaks ties within a team), and the ascending list gives each column its own direction.