**π‘ Problem Formulation:** When working with Pandas DataFrames, it may be required to check if the index consists solely of boolean values (True or False). This is essential for ensuring data integrity, especially when boolean indexing forms a crucial part of data manipulation and analysis. The need arises to validate that an index is purely `True`

or `False`

before operations that depend on boolean logic are performed. For instance, having an index of `[True, False, True]`

is valid, while an index of `[True, 'a', 1]`

is not, and should be detected.

## Method 1: Using the `all()`

function with list comprehension

This method involves using a list comprehension to iterate over the index values and the `all()`

function to check if all values are boolean. This is an explicit method that takes advantage of Python’s capability to evaluate the inherent truthiness of values, combined with the type-checking against the `bool`

class.

Here’s an example:

import pandas as pd df = pd.DataFrame(index=[True, False, True]) is_all_bool = all(isinstance(index, bool) for index in df.index) print(is_all_bool)

Output:

True

This code snippet creates a DataFrame with a boolean index and uses list comprehension along with the `all()`

function to check if all index values are instances of the `bool`

class. The output `True`

indicates that the index is solely boolean.

## Method 2: Using `Index.to_series()`

and `dtype`

check

By converting the index to a series using `Index.to_series()`

and then checking if the `dtype`

of the series is boolean, this method confirms the data type consistency across the entire index. It’s a straightforward approach that ensures all index elements are of the desired boolean data type.

Here’s an example:

df = pd.DataFrame(index=[True, False, True]) is_all_bool = df.index.to_series().dtype is np.bool_ print(is_all_bool)

Output:

True

In this code, the DataFrame’s index is transformed into a series, and the dtype attribute is checked to see if it’s equivalent to `np.bool_`

, which represents the boolean data type in numpy, commonly used in Pandas. The result appropriately flags the index as being fully boolean.

## Method 3: Checking with `pd.api.types.is_bool_dtype()`

Pandas provides a utility function `pd.api.types.is_bool_dtype()`

specifically for type-checking against boolean data types within a DataFrame. This method abstracts away the details and is part of the Pandas type system, which is designed to handle such checks concisely and correctly.

Here’s an example:

df = pd.DataFrame(index=[True, False, True]) is_all_bool = pd.api.types.is_bool_dtype(df.index) print(is_all_bool)

Output:

True

The above snippet uses Pandas’ built-in type-checking function to verify if the DataFrame’s index is of boolean dtype. It’s a clear-cut method provided by Pandas, offering an easy and reliable way to perform this check.

## Method 4: Applying `map()`

with `isinstance()`

Another Pythonic way to determine the uniformity of the index’s data type is by applying the `map()`

function combined with `isinstance()`

to all index values. This applies a type check to each element and ensures they are all boolean.

Here’s an example:

df = pd.DataFrame(index=[True, False, True]) is_all_bool = all(df.index.map(lambda x: isinstance(x, bool))) print(is_all_bool)

Output:

True

This method applies a `lambda`

function that performs an `isinstance()`

check on each index value. The `map()`

method propagates the function across the index, while `all()`

confirms that each value is indeed a boolean.

## Bonus One-Liner Method 5: Using `np.issubdtype()`

NumPy offers the function `np.issubdtype()`

, which allows checking if a type is a subtype of another type. In our case, we can use it in a one-liner to check whether the index dtype is a subtype of boolean.

Here’s an example:

import numpy as np df = pd.DataFrame(index=[True, False, True]) is_all_bool = np.issubdtype(df.index.dtype, np.bool_) print(is_all_bool)

Output:

True

This one-liner utilizes NumPy’s `issubdtype()`

to quickly check if the DataFrame index’s dtype is boolean. It’s a succinct and effective tool that leverages NumPy’s robust type-checking capabilities.

## Summary/Discussion

**Method 1: List Comprehension with**Direct and clear. May not be the most efficient with large indices due to Python-level iteration.`all()`

.**Method 2:**Leverages Pandas’ own data structures. Simple but converts index to a series, which may be unnecessary.`to_series()`

with`dtype`

Check.**Method 3:**Pandas-centric and concise. Best Pandas practice and avoids manual type-checking.`pd.api.types.is_bool_dtype()`

.**Method 4:**Pythonic and uses familiar patterns. Potentially less efficient due to element-wise iteration.`map()`

with`isinstance()`

.**Bonus Method 5:**Efficient and concise one-liner. Relies upon NumPy, introducing an additional library dependency.`np.issubdtype()`

.