Pandas

groupby is lazy — it computes nothing until an op runs. agg reduces each group to one row per key; transform returns the same shape as the input, broadcasting each group's value onto every row; apply is the flexible, slower fallback. Only transform aligns a group aggregate back to the rows without a merge.

Aggregate sales per employee, then attach the name. Group sales by emp_id and sum num_sales, then merge with the names on emp_id: df_sales.groupby('emp_id')['num_sales'].sum().reset_index().merge(df_names, on='emp_id')[['emp_name','num_sales']].

A Series is a labelled 1-D column; a DataFrame is a 2-D table of aligned Series on one index. .loc selects by label, .iloc by integer position. They coincide on a default RangeIndex but split after filtering or a custom index — .loc[0] seeks label 0, maybe absent, while .iloc[0] takes the first row.

Sort by the timestamp, then drop duplicates keeping the last row per key: df.sort_values('updated_at').drop_duplicates('order_id', keep='last'). The sort is what makes keep='last' mean newest; without it you keep whichever row happened to sit last in file order, not the latest update.

fillna(0) suits truly-zero counts but biases a measurement by making unknown a real zero. Mean-fill keeps the mean yet shrinks variance and can leak across a train/test split. Forward-fill fits ordered series but carries a neighbour's value on unordered rows. Each lies when the missingness mechanism differs from its assumption.

Mask the unpaid amounts to zero, then group once. Build paid = df['amount'].where(df['status'].eq('paid'), 0), derive the month from order_ts, and sum: df.assign(paid=paid, m=df['order_ts'].dt.to_period('M')).groupby(['country','m'])['paid'].sum(). The where keeps every row so one pass covers all months.

Pass validate='many_to_one': pandas checks the right key is unique and raises MergeError on a fan-out instead of silently duplicating orders and inflating SUM(amount). Add indicator=True and filter _merge == 'left_only' for unmatched orders — both catch it at merge time.

pivot goes long to wide: df.pivot(index='cohort_month', columns='activity_month', values='users'). melt is the inverse, wide to long. Use pivot only when the index/column pair is unique; if a cell can repeat, pivot_table(..., aggfunc='sum') aggregates the collisions instead of raising.

resample needs a DatetimeIndex, so set_index('date') first, then resample('W')['events'].sum() gives weekly totals (week-ending Sunday). Chain .rolling(4, min_periods=1).mean() for the 4-week average. Unlike a groupby on week number, resample fills empty weeks.

df[mask]['price'] = 0 is chained indexing: df[mask] builds a temporary copy, the write lands there, and df is untouched — so the NaNs stay and pandas warns. Fix it with one indexer: df.loc[df['price'].isna(), 'price'] = 0 (or .fillna). Rule: one .loc/.iloc per write.

.apply(axis=1) runs a Python loop with per-row object boxing and interpreter dispatch — that overhead dominates, not the arithmetic. Replace it with column-wise C ops over whole arrays: boolean masks, np.where/np.select, .str/.dt accessors. That turns minutes into seconds.

Self-merge the table on managerId == id to put each employee beside their manager, then filter where the employee's salary exceeds the manager's. The join key links each row's manager to that manager's own row so the two salaries sit side by side.

Read in pieces with read_csv(chunksize=...) and aggregate each chunk (a chunked groupby), so only one chunk is resident. Cut the footprint with explicit dtype= — downcast numbers, category for low-cardinality strings — and usecols. When chunked pandas still thrashes, use DuckDB or Polars.

Pick each customer's first order, then take the share that are immediate. Get the first-order row indices with groupby('customer_id')['order_date'].idxmin(), select those rows, and compute the mean of the boolean order_date == customer_pref_delivery_date times 100, rounded to 2.

Count how many employees report to each manager, then keep managers meeting the threshold and look up their names. Group by managerId with size(), take the index where the count is >= 5, and return the names of employees whose id is in that set.

Aggregate orders per buyer, then bring in the join date. Group orders by buyer_id for the first order date (min(order_date)) and the order count (size), merge that with users on buyer_id == user_id, and compute delta_days = (first_order - join_date).dt.days.

Build a month key and approved-only helper columns, then group so one pass yields all four aggregates. Set month = trans_date.dt.strftime('%Y-%m'), add is_approved = (state == 'approved') and approved_amount = amount.where(state == 'approved', 0).

A MultiIndex pays off on hierarchical data — a multi-key groupby or stacked panel — giving label-aligned .xs/.loc slicing across levels without a surrogate key. A multi-column .agg returns MultiIndex columns; .reset_index() and joined tuples flatten them into a flat header.

This is a point-in-time lookup. Keep changes on or before the target date, take each product's latest such change (max change_date, e.g. via idxmax after sorting or groupby), and read its new_price. Then reindex against all product ids and fill missing prices with 10 for products with no change by the date.

Filter to trips where both parties are unbanned, then take the daily mean of a cancelled flag. Merge users twice — once on client_id, once on driver_id — to attach each party's ban status, keep rows where neither is banned, restrict to the date range, and group by day.