# How to Calculate the Average or Mean of a Column in a Pandas DataFrame

> Learn how to calculate the average or mean of a column in a pandas DataFrame. Use the simple .mean() function for efficient data analysis with pandas.

- Repository: [pandas/pandas](https://github.com/pandas-dev/pandas)
- Tags: how-to-guide
- Published: 2026-02-16

---

**To calculate the average of a column in a pandas DataFrame, use `df['column_name'].mean()` for a single column or `df.mean()` to compute the mean of all numeric columns.**

The pandas library provides optimized, vectorized operations for statistical computing on tabular data. When you need to calculate the average or mean of a column in a pandas DataFrame, the library delegates your call through a sophisticated architecture that handles missing values, mixed data types, and memory-efficient computation.

## How Pandas Calculates the Mean: Internal Architecture

The `DataFrame.mean()` method is not implemented directly in the DataFrame class. Instead, pandas uses a layered inheritance model that centralizes statistical logic in the `NDFrame` base class.

When you call `df.mean()` or `df['col'].mean()`, the execution flows through these specific source files:

1. **[`pandas/core/frame.py`](https://github.com/pandas-dev/pandas/blob/main/pandas/core/frame.py)** (lines 16344–16431): The public `DataFrame.mean` method acts as a thin wrapper that finalizes the result and handles DataFrame-specific metadata.
2. **[`pandas/core/generic.py`](https://github.com/pandas-dev/pandas/blob/main/pandas/core/generic.py)** (lines 11836–11846): The generic `NDFrame.mean` implementation resides here. It delegates to the internal `_stat_function` helper, passing `nanops.nanmean` as the reduction function.
3. **[`pandas/core/nanops.py`](https://github.com/pandas-dev/pandas/blob/main/pandas/core/nanops.py)**: This file contains the low-level `nanmean` implementation that performs the actual computation while safely ignoring `NaN` values using NumPy operations.

The `_stat_function` helper in `NDFrame` manages **axis selection** (`axis=0` for columns, `axis=1` for rows), **missing-value handling** via `skipna`, and **`numeric_only` filtering** to exclude non-numeric dtypes when required.

## Calculating the Mean of a Single Column

To calculate the average of a specific column, select the column as a **Series** and call `.mean()`:

```python
import pandas as pd

df = pd.DataFrame({
    "a": [1, 2, 3],
    "b": [4, 5, 6],
    "c": ["x", "y", "z"]
})

# Mean of a single column

col_mean = df["a"].mean()
print(col_mean)  # Output: 2.0

```

This invokes `Series.mean()`, which follows the same `NDFrame` inheritance path as DataFrame operations.

## Calculating the Mean of All Columns

By default, `DataFrame.mean()` computes the mean of each numeric column along `axis=0` (vertical axis):

```python

# Mean of each numeric column (default axis=0)

col_means = df.mean()
print(col_means)

# Output:

# a    2.0

# b    5.0

# dtype: float64

```

The method automatically excludes the non-numeric column `"c"` from the calculation. According to the source code in [`pandas/core/generic.py`](https://github.com/pandas-dev/pandas/blob/main/pandas/core/generic.py), this behavior is controlled by the `numeric_only` parameter, which defaults to `None` (inferring numeric columns automatically in many cases, though explicit `numeric_only=True` is recommended for strict control).

## Computing Row-Wise Averages

To calculate the mean across columns for each row, specify `axis=1`:

```python

# Row-wise mean (axis=1)

row_means = df.mean(axis=1)
print(row_means)

# Output:

# 0    2.5

# 1    3.5

# 2    4.5

# dtype: float64

```

As implemented in [`pandas/core/nanops.py`](https://github.com/pandas-dev/pandas/blob/main/pandas/core/nanops.py), the underlying `nanmean` function handles the reduction across the specified axis while ignoring non-numeric values and `NaN` entries.

## Handling Missing Values and Mixed Data Types

The `mean()` method provides explicit control over missing data and dtype handling through the `skipna` and `numeric_only` parameters:

```python
import numpy as np

df_with_nan = pd.DataFrame({
    "a": [1, 2, np.nan],
    "b": [4, np.nan, 6],
    "c": ["x", "y", "z"]
})

# Skip NaN values (default behavior)

mean_skipna = df_with_nan.mean()
print(mean_skipna)

# a    1.5

# b    5.0

# dtype: float64

# Explicitly exclude non-numeric columns

numeric_means = df_with_nan.mean(numeric_only=True)
print(numeric_means)

# a    1.5

# b    5.0

# dtype: float64

# Include NaN values (returns NaN if any present)

mean_with_na = df_with_nan.mean(skipna=False)
print(mean_with_na)

# a     NaN

# b     NaN

# dtype: float64

```

According to the source code in [`pandas/core/generic.py`](https://github.com/pandas-dev/pandas/blob/main/pandas/core/generic.py), the `skipna` parameter defaults to `True`, ensuring that `NaN` values are ignored during the reduction. The `numeric_only` parameter filters the DataFrame to include only float, int, and boolean dtypes before passing the data to `nanops.nanmean`.

## Summary

- **Single column**: Use `df['column'].mean()` to return a scalar value for a specific Series.
- **All columns**: Use `df.mean()` (default `axis=0`) to compute means for each numeric column, automatically excluding non-numeric data.
- **Row-wise**: Set `axis=1` to calculate means across columns for each row.
- **Missing data**: The default `skipna=True` ignores `NaN` values; set `skipna=False` to propagate them.
- **Type safety**: Use `numeric_only=True` to explicitly filter for numeric columns and avoid deprecation warnings.
- **Implementation**: The operation flows through [`pandas/core/frame.py`](https://github.com/pandas-dev/pandas/blob/main/pandas/core/frame.py) → [`pandas/core/generic.py`](https://github.com/pandas-dev/pandas/blob/main/pandas/core/generic.py) → [`pandas/core/nanops.py`](https://github.com/pandas-dev/pandas/blob/main/pandas/core/nanops.py), utilizing `NDFrame._stat_function` and `nanops.nanmean` for efficient computation.

## Frequently Asked Questions

### How do I calculate the mean of a specific column in pandas?

To calculate the mean of a specific column, select the column using bracket notation to create a Series, then call the `.mean()` method. For example, `df['column_name'].mean()` returns the arithmetic mean as a float, automatically skipping any `NaN` values by default according to the implementation in [`pandas/core/generic.py`](https://github.com/pandas-dev/pandas/blob/main/pandas/core/generic.py).

### What is the difference between `mean()` and `average()` in pandas?

Pandas does not provide an `average()` method for DataFrame or Series objects. The standard method for computing the arithmetic mean is `mean()`. While NumPy provides both `np.mean()` and `np.average()` (where the latter supports weighted averages), pandas exclusively uses `mean()` for unweighted arithmetic means, as implemented in the `NDFrame` base class.

### How does pandas handle NaN values when calculating the mean?

By default, pandas ignores `NaN` values when calculating the mean via the `skipna=True` parameter, which is passed through `NDFrame._stat_function` in [`pandas/core/generic.py`](https://github.com/pandas-dev/pandas/blob/main/pandas/core/generic.py) to the `nanops.nanmean` implementation in [`pandas/core/nanops.py`](https://github.com/pandas-dev/pandas/blob/main/pandas/core/nanops.py). If you set `skipna=False`, the presence of any `NaN` in the column or row will result in a `NaN` return value for that aggregation.

### Why do I get a warning about `numeric_only` when calling `df.mean()`?

In recent versions of pandas, calling `df.mean()` without specifying `numeric_only` may raise a warning or future error if your DataFrame contains non-numeric columns (such as strings or objects). To resolve this, explicitly set `numeric_only=True` to restrict the calculation to float, integer, and boolean columns, or `numeric_only=False` to attempt the operation on all columns (which will raise an error if non-numeric data is present). This filtering occurs in the `_stat_function` helper within [`pandas/core/generic.py`](https://github.com/pandas-dev/pandas/blob/main/pandas/core/generic.py).