Python Pandas: How to Check if All Values in a Column (or Row) Are Equal

Learn efficient methods to validate if all values in a Pandas DataFrame column, row, or specific subset are identical using nunique(), NumPy arrays, and row-wise comparisons.

When cleaning or analyzing data with Pandas, you might need to verify if all values within a specific column are identical, or if all values across columns in a particular row are the same. This can be important for data validation, identifying constant features, or simplifying datasets.

This guide demonstrates various methods to check for equality of values within Pandas DataFrame columns and rows.

The Goal: Checking for Uniformity in Values

We aim to determine:

If every value within one particular column is the same.
If every value within each respective column is the same (i.e., each column is constant, but different columns can have different constant values).
If all values across specified columns for a given row are identical.

Example DataFrame

import pandas as pd
import numpy as np # For some examples

data = {
    'ID': [101, 102, 103, 104, 105],
    'Category': ['A', 'A', 'A', 'A', 'A'],                              # All values are 'A'
    'Status': ['Active', 'Active', 'Inactive', 'Active', 'Inactive'],   # Mixed values
    'Value1': [10, 10, 10, 10, 10],                                     # All values are 10
    'Value2': [10, 20, 10, 20, 10],                                     # Mixed values
    'All_Same_Row_Example': [5, 5, 5, 5, 5]                             # All values in this column are 5
}

df = pd.DataFrame(data)
print("Original DataFrame:")
print(df)

Output:

Original DataFrame:
    ID Category    Status  Value1  Value2  All_Same_Row_Example
0  101        A    Active      10      10                     5
1  102        A    Active      10      20                     5
2  103        A  Inactive      10      10                     5
3  104        A    Active      10      20                     5
4  105        A  Inactive      10      10                     5

Check if ALL Values in a SINGLE Column Are Equal

Comparing All Elements to the First (NumPy approach - Recommended)

Convert the column to a NumPy array and check if all elements are equal to the first element. This is generally efficient.

import pandas as pd

df = pd.DataFrame({
    'ID': [101, 102, 103, 104, 105],
    'Category': ['A', 'A', 'A', 'A', 'A'],
    'Status': ['Active', 'Active', 'Inactive', 'Active', 'Inactive'],
})

def all_values_equal_in_column(series):
  """Checks if all values in a Pandas Series are equal."""
  if series.empty:
    return True # Or False, depending on how you define for empty
  arr = series.to_numpy()
  return (arr == arr[0]).all()

print(f"Are all values in 'Category' equal? {all_values_equal_in_column(df['Category'])}")
print(f"Are all values in 'Status' equal? {all_values_equal_in_column(df['Status'])}")

Output:

Are all values in 'Category' equal? True
Are all values in 'Status' equal? False

series.to_numpy(): Converts the Pandas Series to a NumPy array.
arr == arr[0]: Creates a boolean array comparing each element to the first.
.all(): Returns True if all elements in the boolean array are True.

Note

By default, NaN == NaN is False. If NaNs should be considered equal:

def all_values_equal_nan_aware(series):
  if series.empty: return True
  first_val = series.iloc[0]
  if pd.isna(first_val):
    return series.isna().all()
  else:
    return (series == first_val).all()

Using `Series.nunique()`

The nunique() method counts the number of distinct elements. If there's only one unique element (or zero for an empty Series), all values are effectively the same.

import pandas as pd

df = pd.DataFrame({
    'ID': [101, 102, 103, 104, 105],
    'Category': ['A', 'A', 'A', 'A', 'A'],
    'Status': ['Active', 'Active', 'Inactive', 'Active', 'Inactive'],
})

is_category_constant = df['Category'].nunique(dropna=True) <= 1 # dropna=True is default
is_status_constant = df['Status'].nunique() <= 1

print(f"Using nunique(): 'Category' constant? {is_category_constant}")
print(f"Using nunique(): 'Status' constant? {is_status_constant}")

empty_series = pd.Series([], dtype=object)
print(f"Using nunique(): Empty series constant? {empty_series.nunique() <= 1}")

Output:

Using nunique(): 'Category' constant? True
Using nunique(): 'Status' constant? False
Using nunique(): Empty series constant? True

dropna=True (default): NaN values are not counted as a unique value.
dropna=False: NaN values are counted as one unique value if present.
<= 1: Accounts for empty Series (0 unique) and constant Series (1 unique).

Using `len(Series.unique())`

Similar to nunique(), but unique() returns an array of unique values.

import pandas as pd

df = pd.DataFrame({
    'ID': [101, 102, 103, 104, 105],
    'Category': ['A', 'A', 'A', 'A', 'A'],
    'Status': ['Active', 'Active', 'Inactive', 'Active', 'Inactive'],
})

is_category_constant_unique = len(df['Category'].unique()) <= 1
print(f"Using len(unique()): 'Category' constant? {is_category_constant_unique}")

Output:

Using len(unique()): 'Category' constant? True

unique() also handles NaNs as a single unique value if present.

Check if ALL Values in EACH Column Are Equal (Across Entire DataFrame)

This checks if each column individually consists of identical values (but different columns can have different constant values).

import pandas as pd

df = pd.DataFrame({
    'ID': [101, 102, 103, 104, 105],
    'Category': ['A', 'A', 'A', 'A', 'A'],
    'Status': ['Active', 'Active', 'Inactive', 'Active', 'Inactive'],
    'Value1': [10, 10, 10, 10, 10],
})

constant_columns_mask = df.apply(lambda col: col.nunique() <= 1)

print("Are all values in each column respectively equal?")
print(constant_columns_mask)

print(f"Are all columns constant? {constant_columns_mask.all()}")

Output:

Are all values in each column respectively equal?
ID          False
Category     True
Status      False
Value1       True
dtype: bool
Are all columns constant? False

The df.apply() method applies a function along an axis (default axis=0, which is column-wise).

Check if ALL Values in a DataFrame Are Equal to a SPECIFIC Value

To check if every cell in selected columns (or the whole DataFrame) is equal to a single specific value.

import pandas as pd

df_all_ones = pd.DataFrame({'A': [1, 1, 1], 'B': [1, 1, 1]})
df_mixed_ones = pd.DataFrame({'A': [1, 1, 1], 'B': [1, 0, 1]})

target_value = 1

all_equal_to_target_df1 = (df_all_ones == target_value).all().all()
print(f"Is df_all_ones entirely '{target_value}'? {all_equal_to_target_df1}")

all_equal_to_target_df2 = (df_mixed_ones == target_value).all().all()
print(f"Is df_mixed_ones entirely '{target_value}'? {all_equal_to_target_df2}")

Output:

Is df_all_ones entirely '1'? True
Is df_mixed_ones entirely '1'? False

df == target_value: Element-wise comparison, returns a DataFrame of booleans.
.all(): Called once, checks if all values are True within each column. Returns a boolean Series.
.all(): Called a second time on the boolean Series, checks if all those values (for all columns) are True.

Note

You can also check specific columns. Assume 'df' is the larger example DataFrame: are all values in 'Category' equal to 'A'?

is_category_all_A = (df['Category'] == 'A').all()
print(f"Is 'Category' column all 'A'? {is_category_all_A}")

Find Rows Where ALL Column Values Are Equal

This checks if, for each row, all values across the specified columns (or all columns) are identical to each other within that row.

Comparing Each Column to the First Column

import pandas as pd

df_rows_check = pd.DataFrame({
    'Col1': ['X', 'Y', 'Z', 'W'],
    'Col2': ['X', 'Y', 'A', 'W'],
    'Col3': ['X', 'Y', 'B', 'W'],
    'Col4': ['P', 'Y', 'C', 'W'] # Deliberately different in first row
})
df_rows_check.iloc[0,3] = 'X' # Make first row all 'X' for demo

print("DataFrame for row equality check:")
print(df_rows_check)
print()

all_values_equal_in_row_mask = df_rows_check.eq(df_rows_check.iloc[:, 0], axis=0).all(axis=1)

print("Mask indicating rows where all values are equal:")
print(all_values_equal_in_row_mask)
print()

print("Rows where all values are equal:")
print(df_rows_check[all_values_equal_in_row_mask])
print()

Output:

DataFrame for row equality check:
  Col1 Col2 Col3 Col4
0    X    X    X    X
1    Y    Y    Y    Y
2    Z    A    B    C
3    W    W    W    W

Mask indicating rows where all values are equal:
0     True
1     True
2    False
3     True
dtype: bool

Rows where all values are equal:
  Col1 Col2 Col3 Col4
0    X    X    X    X
1    Y    Y    Y    Y
3    W    W    W    W

df.eq(df.iloc[:, 0], axis=0): Compares each column element-wise to the corresponding element in the first column (df.iloc[:, 0]). axis=0 ensures row-wise broadcasting of the first column for comparison.
.all(axis=1): Checks if all boolean values are True across each row (axis=1).

Comparing All Elements in a Row (Using `nunique` per row)

import pandas as pd

df_rows_check = pd.DataFrame({
    'Col1': ['X', 'Y', 'Z', 'W'],
    'Col2': ['X', 'Y', 'A', 'W'],
    'Col3': ['X', 'Y', 'B', 'W'],
    'Col4': ['X', 'Y', 'C', 'W']
})

all_values_equal_in_row_mask_nunique = df_rows_check.nunique(axis=1, dropna=False) == 1

print("Mask indicating rows where all values are equal (nunique approach):")
print(all_values_equal_in_row_mask_nunique)

Output:

Mask indicating rows where all values are equal (nunique approach):
0     True
1     True
2    False
3     True
dtype: bool

Check if Specific Columns in Each Row Are Equal

If you need to check if values in a subset of columns are equal for each row.

import pandas as pd

df_specific_cols = pd.DataFrame({
    'A': [1, 2, 1, 3],
    'B': [1, 5, 1, 3],
    'C': [1, 2, 0, 3],
    'D': ['x', 'y', 'z', 'w']
})
cols_to_compare = ['A', 'B', 'C']

df_specific_cols['Are_ABC_Equal'] = df_specific_cols[cols_to_compare].apply(
    lambda row: row.nunique() == 1, axis=1
)

print("Checking if specific columns A, B, C are equal per row:")
print(df_specific_cols)

Output:

Checking if specific columns A, B, C are equal per row:
   A  B  C  D  Are_ABC_Equal
0  1  1  1  x           True
1  2  5  2  y          False
2  1  1  0  z          False
3  3  3  3  w           True

Conclusion

Checking for equality of values within Pandas DataFrames is a key data validation step:

To check if all values in a single column are equal, (col.to_numpy() == col.to_numpy()[0]).all() or col.nunique() <= 1 are effective.
To check if each column individually has all equal values, use df.apply(lambda col: col.nunique() <= 1).
To find rows where all values across columns are equal, df.eq(df.iloc[:, 0], axis=0).all(axis=1) or df.nunique(axis=1) == 1 are good approaches.
To compare specific columns within each row, use df[cols_to_compare].apply(lambda row: row.nunique()==1, axis=1).

Choose the method that best reflects the specific type of equality check you need to perform on your DataFrame.

Python Pandas: How to Check if All Values in a Column (or Row) Are Equal

The Goal: Checking for Uniformity in Values

Example DataFrame

Check if ALL Values in a SINGLE Column Are Equal

Comparing All Elements to the First (NumPy approach - Recommended)

Using Series.nunique()

Using len(Series.unique())

Check if ALL Values in EACH Column Are Equal (Across Entire DataFrame)

Check if ALL Values in a DataFrame Are Equal to a SPECIFIC Value

Find Rows Where ALL Column Values Are Equal

Comparing Each Column to the First Column

Comparing All Elements in a Row (Using nunique per row)

Check if Specific Columns in Each Row Are Equal

Conclusion

Using `Series.nunique()`

Using `len(Series.unique())`

Comparing All Elements in a Row (Using `nunique` per row)