Pandas GroupBy: Summaries or Row-Level Results?

Updated 9 November 2026 · Standard formula, shown below

With pandas groupby, use an aggregation such as sum or mean when you want one summary per group; use transform when you need a group-based result for every original row. The key difference is the shape: aggregation reduces each group, while transformation returns values aligned to the original rows.

What GroupBy Does

groupby divides a DataFrame or Series into groups according to one or more keys. You can then calculate a result for each group, apply a function to each group, or filter groups. This split–apply–combine pattern is useful for questions such as “What is the average sale per store?” and “How far is each sale from its store’s average?”

For example, suppose df contains store and sales columns. Grouping by store creates logical groups of rows, but it does not by itself decide whether the output should contain fewer rows or remain row-level. The method that follows groupby determines that.

Use Aggregation for One Result per Group

Aggregation combines the values in each group into one or more summary values. Use agg (or its alias aggregate) for named statistics such as totals, averages, counts, minima, and maxima.

summary = df.groupby("store")["sales"].sum()

This returns a Series with one total per store, rather than one value per sale. To calculate several statistics at once:

summary = df.groupby("store")["sales"].agg(["sum", "mean", "count"])

For multiple columns, or to give output columns clearer names, use named aggregation:

summary = df.groupby("store").agg(
    total_sales=("sales", "sum"),
    average_sale=("sales", "mean"),
    sale_count=("sales", "count"),
)

The result has one row per group and columns for the requested statistics. This is usually the right choice for reports, charts of group totals, and tables that will be joined to other group-level data.

Use Transform for a Result on Every Row

transform applies a group-wise calculation and returns a result with the same index and number of rows as the object it was called on. Each row receives a value corresponding to its group.

df["store_average"] = (
    df.groupby("store")["sales"].transform("mean")
)

If a store has sales of 10, 20, and 30, its group average is 20, so transform("mean") supplies 20 for all three rows. The original rows remain in place, making the result easy to assign as a new column.

Transform is especially useful for comparisons against group statistics. For instance, subtract each store’s average from each sale:

df["above_or_below_average"] = (
    df["sales"] - df.groupby("store")["sales"].transform("mean")
)

Each value now shows a row’s difference from its own store’s average, without collapsing the sales records.

How to Choose

Start with the shape and purpose of the result, not just the statistic you want to calculate:

Choose aggregation if the output should have one row per group, such as a total or mean for every store.
Choose transform if the output should stay aligned with individual records, such as a group mean repeated beside each row.
Choose filtering with filter if you want to keep or remove entire groups based on a condition.
Choose a group-wise custom operation with apply when the task does not fit the standard aggregation, transformation, or filtering patterns.

A useful rule of thumb: if you plan to assign the result directly as a new column on the original DataFrame, transform is often the appropriate method. If you are creating a smaller summary table, use aggregation.

Shape, Indexes, and Common Problems

The most common error is expecting an aggregation result to line up with the original rows. A group sum has one value per group, so assigning it directly to a DataFrame with many more rows generally will not produce the intended row-level comparison. Use transform to broadcast a group statistic across that group’s rows.

Also distinguish between size and count. GroupBy.size() counts rows in each group, including rows where a selected column is missing. GroupBy["column"].count() counts non-missing values in that column. Choose based on whether missing values should count.

By default, missing values in grouping keys are generally excluded from groups. If they should form a group, check the dropna parameter supported by the relevant pandas operation and set it appropriately. Group ordering and index structure can also affect how results display. Use as_index=False when you want group keys as ordinary columns in an aggregated DataFrame, or use reset_index() to turn an index into columns afterward.

Finally, pandas aligns many assignments by index labels, not merely by row position. If you have sorted, filtered, or otherwise changed indexes, check that the result’s index corresponds to the rows you intend. A transformed Series is designed to preserve alignment with its grouped input; an aggregated result has a different, group-level shape.

Aggregation, Transform, and Apply Compared

These methods can sometimes calculate similar numbers, but they express different output intentions. Aggregation reduces groups; transformation returns same-length results; apply gives a function more flexibility over each group’s output and can produce less predictable shapes.

Prefer built-in operations such as sum, mean, and transform("rank") when they fit. They communicate the expected result clearly and are generally more efficient than a Python function passed to apply. Use apply when a group-specific operation genuinely needs a custom result, and inspect its output before relying on its index or shape.

One misconception is that transform is simply a way to make an aggregate “look bigger.” It does repeat a group-level result across rows, but it can also perform element-wise group operations, such as ranking or cumulative sums. The defining property is that the output remains aligned to the input’s rows, not that every transformed value must be identical within a group.

Frequently Asked Questions

How do I add a group average to every row?
Use df.groupby("group_column")["value_column"].transform("mean"), then assign the resulting Series to a new column.

Why does groupby aggregation return fewer rows?
Aggregation produces a summary for each group, so multiple input rows are combined into one output result per group.

Can I use transform with several columns?
Yes. You can transform a grouped DataFrame or select a particular grouped column. The returned result must satisfy the transform shape rules and align with the input rows.

Should I use apply or transform?
Use transform for same-length, row-aligned results and apply for custom group operations that need a different output shape. Prefer built-in methods where possible.

How can I keep group keys as columns after aggregation?
Use groupby(..., as_index=False) with an aggregation, or call reset_index() on the resulting summary.

Method: the standard formula for this calculation, rounded as each result states. See how the calculators work or report an error.