Renaming, sorting and dropping

The unglamorous operations that make a table readable. Two things in here catch people out, so they're flagged as we go.

Renaming

orders.rename(columns={"cups": "cups_sold"})
orders.rename(index={0: "first"})
orders.rename(columns=str.lower)            # a function works too
orders.columns = ["a", "b", "c", "d", "e", "f"]   # replace them all

The mapping form only touches the columns you name, so it's safe against a table whose other columns you don't know about. Assigning to .columns replaces every name and requires exactly the right count — fine after a groupby, risky otherwise.

A quick way to tidy a whole set of messy headers:

df.columns = df.columns.str.strip().str.lower().str.replace(" ", "_")

Sorting by value

orders.sort_values("cups", ascending=False)
orders.sort_values(["city", "cups"])                       # city, then cups within it
orders.sort_values(["city", "cups"], ascending=[True, False])
orders.nlargest(3, "cups")                                 # top 3 without a full sort

First footgun. Sorting moves rows but not their labels. After sorting by cups, the index reads 3, 0, 2, 1, 4 — so .iloc[0] is now the biggest row while .loc[0] is still whichever row was always called 0. Exactly the same rule as filtering, and the same source of quiet bugs.

If you want the labels renumbered to match the new order, say so: .sort_values("cups").reset_index(drop=True).

Missing values sort last

orders.sort_values("rating")                        # NaN at the end
orders.sort_values("rating", na_position="first")   # NaN at the top

Gaps go last whichever direction you sort, which is usually what you want — and na_position="first" is a neat way to bring the incomplete rows to the top when you're hunting for them.

Sorting by index

orders.sort_index()          # by the row labels
orders.sort_index(axis=1)    # puts the COLUMNS in alphabetical order

Worth doing after a concat or a merge. A sorted index makes label lookups a binary search rather than a scan, and label slicing (df.loc["a":"c"]) expects one.

Dropping

orders.drop(columns=["rating"])
orders.drop(index=[0, 1])
orders.drop(columns=["rating"], errors="ignore")   # do not raise if absent

Always name the axis. drop has an older positional form that guesses, and the guess is not always what you meant.

The second footgun

Every method on this page returns a copy. None of them changes the frame you called them on:

orders.drop(columns=["rating"])       # computes a new frame and throws it away
orders = orders.drop(columns=["rating"])   # this is what you meant

You'll see inplace=True in older code. It's discouraged now — it doesn't actually save memory, it breaks method chaining, and it returns None, so df = df.drop(..., inplace=True) silently destroys your frame. Assign the result instead.

Which points at the better habit — chaining these together, since each returns a frame:

clean = (
    orders
    .drop_duplicates()
    .dropna(subset=["rating"])
    .rename(columns={"cups": "cups_sold"})
    .sort_values("cups_sold", ascending=False)
    .reset_index(drop=True)
)

That reads top to bottom as a list of steps, and there's no half-modified frame anywhere.