# 5 Best Ways to Find NaN Indexes in a Python Series

Rate this post

π‘ Problem Formulation: You’re dealing with a series of data in Python, and you need to find the locations of not-a-number (NaN) values. Such values often represent missing data and can affect the accuracy of your calculations or analysis. For a given series, e.g., `pd.Series([1, np.nan, 3, np.nan, 5])`, your goal is to locate the index positions of the NaNs, which in this case would be `[1, 3]`.

## Method 1: Using Pandas `isna()` Function

This method involves using the `isna()` function provided by the pandas library. The function returns a boolean series indicating whether each value is missing (`NaN`). By combining this with the `where()` function, you get the indices of all NaN values. This method is clear and pandas-native, which makes it a popular choice among data scientists.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# One-liner using filter() and pd.isna()
nan_indices = list(filter(lambda idx: pd.isna(series[idx]), range(len(series))))

print(nan_indices)```

Output:

`[1, 3]`

This approach uses `filter()` to iterate over each index and applies `lambda` to check if the value at that index is NaN, using `pd.isna()`. This effectively filters out non-NaN indices, leaving only the indices of NaNs.

## Summary/Discussion

• Method 1: Pandas `isna()` with `where()`. Strengths: Native to pandas, readable, and convenient. Weaknesses: Dependent on pandas, not suitable for native Python lists.
• Method 2: List Comprehension with `math.isnan()`. Strengths: Versatile and straightforward, works outside pandas. Weaknesses: Can raise type errors if non-float values are present.
• Method 3: NumPy’s `argwhere()` with `isnan()`. Strengths: Efficient with NumPy’s optimized operations. Weaknesses: Requires conversion to NumPy array, added dependency on the NumPy library.
• Method 4: Pandas Boolean Masking. Strengths: Clean and idiomatic for pandas users. Weaknesses: Limited to pandas data structures.
• Method 5: Using `filter()` with `pd.isna()`. Strengths: Pythonic one-liner, clear intent. Weaknesses: May be less intuitive for those new to functional programming paradigms.
```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Applying boolean masking to get indices of NaN values
nan_indices = series.index[series.isna()]

print(nan_indices.tolist())```

Output:

`[1, 3]`

Here, `series.isna()` creates a boolean mask, and when applied to `series.index`, it delivers the indices of NaNs. This method is straightforward and idiomatic when working with pandas.

## Bonus One-Liner Method 5: Using `filter()` with `pd.isna()`

A concise one-liner that uses Python’s built-in `filter()` function combined with `pd.isna()` can yield NaN indices without the need for explicit loops or comprehensions. This is a Pythonic way to handle this search and reads nicely in code.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# One-liner using filter() and pd.isna()
nan_indices = list(filter(lambda idx: pd.isna(series[idx]), range(len(series))))

print(nan_indices)```

Output:

`[1, 3]`

This approach uses `filter()` to iterate over each index and applies `lambda` to check if the value at that index is NaN, using `pd.isna()`. This effectively filters out non-NaN indices, leaving only the indices of NaNs.

## Summary/Discussion

• Method 1: Pandas `isna()` with `where()`. Strengths: Native to pandas, readable, and convenient. Weaknesses: Dependent on pandas, not suitable for native Python lists.
• Method 2: List Comprehension with `math.isnan()`. Strengths: Versatile and straightforward, works outside pandas. Weaknesses: Can raise type errors if non-float values are present.
• Method 3: NumPy’s `argwhere()` with `isnan()`. Strengths: Efficient with NumPy’s optimized operations. Weaknesses: Requires conversion to NumPy array, added dependency on the NumPy library.
• Method 4: Pandas Boolean Masking. Strengths: Clean and idiomatic for pandas users. Weaknesses: Limited to pandas data structures.
• Method 5: Using `filter()` with `pd.isna()`. Strengths: Pythonic one-liner, clear intent. Weaknesses: May be less intuitive for those new to functional programming paradigms.
```import numpy as np

# Creating a NumPy array with NaN values
array = np.array([2, np.nan, 5, np.nan, 7])

# Using NumPy's isnan() along with argwhere() to find indices of NaNs
nan_indices = np.argwhere(np.isnan(array)).flatten()

print(nan_indices)```

Output:

`[1 3]`

The code utilizes NumPy’s `isnan()` to find NaNs in the array, then `argwhere()` to extract their positions. The resulting array is flattened to get a one-dimensional array of indices.

## Method 4: Using Pandas `index` with Boolean Masking

Another pandas-centric method employs boolean masking directly to the series’ `index` property. This takes advantage of the fact that pandas indexes can be used to filter series and dataframes just like arrays.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Applying boolean masking to get indices of NaN values
nan_indices = series.index[series.isna()]

print(nan_indices.tolist())```

Output:

`[1, 3]`

Here, `series.isna()` creates a boolean mask, and when applied to `series.index`, it delivers the indices of NaNs. This method is straightforward and idiomatic when working with pandas.

## Bonus One-Liner Method 5: Using `filter()` with `pd.isna()`

A concise one-liner that uses Python’s built-in `filter()` function combined with `pd.isna()` can yield NaN indices without the need for explicit loops or comprehensions. This is a Pythonic way to handle this search and reads nicely in code.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# One-liner using filter() and pd.isna()
nan_indices = list(filter(lambda idx: pd.isna(series[idx]), range(len(series))))

print(nan_indices)```

Output:

`[1, 3]`

This approach uses `filter()` to iterate over each index and applies `lambda` to check if the value at that index is NaN, using `pd.isna()`. This effectively filters out non-NaN indices, leaving only the indices of NaNs.

## Summary/Discussion

• Method 1: Pandas `isna()` with `where()`. Strengths: Native to pandas, readable, and convenient. Weaknesses: Dependent on pandas, not suitable for native Python lists.
• Method 2: List Comprehension with `math.isnan()`. Strengths: Versatile and straightforward, works outside pandas. Weaknesses: Can raise type errors if non-float values are present.
• Method 3: NumPy’s `argwhere()` with `isnan()`. Strengths: Efficient with NumPy’s optimized operations. Weaknesses: Requires conversion to NumPy array, added dependency on the NumPy library.
• Method 4: Pandas Boolean Masking. Strengths: Clean and idiomatic for pandas users. Weaknesses: Limited to pandas data structures.
• Method 5: Using `filter()` with `pd.isna()`. Strengths: Pythonic one-liner, clear intent. Weaknesses: May be less intuitive for those new to functional programming paradigms.
```import math

# A non-pandas series (list)
series = [2, np.nan, 5, np.nan, 7]

# Using list comprehension with math.isnan() to find indices of NaNs
nan_indices = [index for index, value in enumerate(series) if math.isnan(value)]

print(nan_indices)```

Output:

`[1, 3]`

This snippet loops through the series with `enumerate()`, which yields both the index and value. It then uses `math.isnan()` to check for NaN and keep the index if the value is NaN. It’s a concise method but requires caution with types since `math.isnan()` won’t handle non-float values.

## Method 3: Using NumPy’s `argwhere()` Combined with `isnan()`

NumPy provides a function `isnan()` which, like pandas’ `isna()`, returns a boolean array. However, by combining this with `argwhere()`, you get the indices directly as a NumPy array. This approach is efficient and makes use of NumPy’s optimized operations.

Here’s an example:

```import numpy as np

# Creating a NumPy array with NaN values
array = np.array([2, np.nan, 5, np.nan, 7])

# Using NumPy's isnan() along with argwhere() to find indices of NaNs
nan_indices = np.argwhere(np.isnan(array)).flatten()

print(nan_indices)```

Output:

`[1 3]`

The code utilizes NumPy’s `isnan()` to find NaNs in the array, then `argwhere()` to extract their positions. The resulting array is flattened to get a one-dimensional array of indices.

## Method 4: Using Pandas `index` with Boolean Masking

Another pandas-centric method employs boolean masking directly to the series’ `index` property. This takes advantage of the fact that pandas indexes can be used to filter series and dataframes just like arrays.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Applying boolean masking to get indices of NaN values
nan_indices = series.index[series.isna()]

print(nan_indices.tolist())```

Output:

`[1, 3]`

Here, `series.isna()` creates a boolean mask, and when applied to `series.index`, it delivers the indices of NaNs. This method is straightforward and idiomatic when working with pandas.

## Bonus One-Liner Method 5: Using `filter()` with `pd.isna()`

A concise one-liner that uses Python’s built-in `filter()` function combined with `pd.isna()` can yield NaN indices without the need for explicit loops or comprehensions. This is a Pythonic way to handle this search and reads nicely in code.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# One-liner using filter() and pd.isna()
nan_indices = list(filter(lambda idx: pd.isna(series[idx]), range(len(series))))

print(nan_indices)```

Output:

`[1, 3]`

This approach uses `filter()` to iterate over each index and applies `lambda` to check if the value at that index is NaN, using `pd.isna()`. This effectively filters out non-NaN indices, leaving only the indices of NaNs.

## Summary/Discussion

• Method 1: Pandas `isna()` with `where()`. Strengths: Native to pandas, readable, and convenient. Weaknesses: Dependent on pandas, not suitable for native Python lists.
• Method 2: List Comprehension with `math.isnan()`. Strengths: Versatile and straightforward, works outside pandas. Weaknesses: Can raise type errors if non-float values are present.
• Method 3: NumPy’s `argwhere()` with `isnan()`. Strengths: Efficient with NumPy’s optimized operations. Weaknesses: Requires conversion to NumPy array, added dependency on the NumPy library.
• Method 4: Pandas Boolean Masking. Strengths: Clean and idiomatic for pandas users. Weaknesses: Limited to pandas data structures.
• Method 5: Using `filter()` with `pd.isna()`. Strengths: Pythonic one-liner, clear intent. Weaknesses: May be less intuitive for those new to functional programming paradigms.
```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Using isna() to find NaN values and then getting their indices
nan_indices = series.isna().where(lambda x: x).dropna().index.tolist()

print(nan_indices)```

Output:

`[1, 3]`

This code first marks all NaN values as `True` using `isna()`, then filters to keep only those `True` values using `where()`. Finally, it removes all non-existent entries (if any) with `dropna()` and collects the indices into a list.

## Method 2: Using List Comprehension with `math.isnan()`

If you’re not working within the pandas framework, you can use Python’s `math` library in conjunction with a list comprehension to identify NaN values. This method is suitable for any iterable and does not require pandas, making it versatile for use with lists and other sequences.

Here’s an example:

```import math

# A non-pandas series (list)
series = [2, np.nan, 5, np.nan, 7]

# Using list comprehension with math.isnan() to find indices of NaNs
nan_indices = [index for index, value in enumerate(series) if math.isnan(value)]

print(nan_indices)```

Output:

`[1, 3]`

This snippet loops through the series with `enumerate()`, which yields both the index and value. It then uses `math.isnan()` to check for NaN and keep the index if the value is NaN. It’s a concise method but requires caution with types since `math.isnan()` won’t handle non-float values.

## Method 3: Using NumPy’s `argwhere()` Combined with `isnan()`

NumPy provides a function `isnan()` which, like pandas’ `isna()`, returns a boolean array. However, by combining this with `argwhere()`, you get the indices directly as a NumPy array. This approach is efficient and makes use of NumPy’s optimized operations.

Here’s an example:

```import numpy as np

# Creating a NumPy array with NaN values
array = np.array([2, np.nan, 5, np.nan, 7])

# Using NumPy's isnan() along with argwhere() to find indices of NaNs
nan_indices = np.argwhere(np.isnan(array)).flatten()

print(nan_indices)```

Output:

`[1 3]`

The code utilizes NumPy’s `isnan()` to find NaNs in the array, then `argwhere()` to extract their positions. The resulting array is flattened to get a one-dimensional array of indices.

## Method 4: Using Pandas `index` with Boolean Masking

Another pandas-centric method employs boolean masking directly to the series’ `index` property. This takes advantage of the fact that pandas indexes can be used to filter series and dataframes just like arrays.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Applying boolean masking to get indices of NaN values
nan_indices = series.index[series.isna()]

print(nan_indices.tolist())```

Output:

`[1, 3]`

Here, `series.isna()` creates a boolean mask, and when applied to `series.index`, it delivers the indices of NaNs. This method is straightforward and idiomatic when working with pandas.

## Bonus One-Liner Method 5: Using `filter()` with `pd.isna()`

A concise one-liner that uses Python’s built-in `filter()` function combined with `pd.isna()` can yield NaN indices without the need for explicit loops or comprehensions. This is a Pythonic way to handle this search and reads nicely in code.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# One-liner using filter() and pd.isna()
nan_indices = list(filter(lambda idx: pd.isna(series[idx]), range(len(series))))

print(nan_indices)```

Output:

`[1, 3]`

This approach uses `filter()` to iterate over each index and applies `lambda` to check if the value at that index is NaN, using `pd.isna()`. This effectively filters out non-NaN indices, leaving only the indices of NaNs.

## Summary/Discussion

• Method 1: Pandas `isna()` with `where()`. Strengths: Native to pandas, readable, and convenient. Weaknesses: Dependent on pandas, not suitable for native Python lists.
• Method 2: List Comprehension with `math.isnan()`. Strengths: Versatile and straightforward, works outside pandas. Weaknesses: Can raise type errors if non-float values are present.
• Method 3: NumPy’s `argwhere()` with `isnan()`. Strengths: Efficient with NumPy’s optimized operations. Weaknesses: Requires conversion to NumPy array, added dependency on the NumPy library.
• Method 4: Pandas Boolean Masking. Strengths: Clean and idiomatic for pandas users. Weaknesses: Limited to pandas data structures.
• Method 5: Using `filter()` with `pd.isna()`. Strengths: Pythonic one-liner, clear intent. Weaknesses: May be less intuitive for those new to functional programming paradigms.
```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Applying boolean masking to get indices of NaN values
nan_indices = series.index[series.isna()]

print(nan_indices.tolist())```

Output:

`[1, 3]`

Here, `series.isna()` creates a boolean mask, and when applied to `series.index`, it delivers the indices of NaNs. This method is straightforward and idiomatic when working with pandas.

## Bonus One-Liner Method 5: Using `filter()` with `pd.isna()`

A concise one-liner that uses Python’s built-in `filter()` function combined with `pd.isna()` can yield NaN indices without the need for explicit loops or comprehensions. This is a Pythonic way to handle this search and reads nicely in code.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# One-liner using filter() and pd.isna()
nan_indices = list(filter(lambda idx: pd.isna(series[idx]), range(len(series))))

print(nan_indices)```

Output:

`[1, 3]`

This approach uses `filter()` to iterate over each index and applies `lambda` to check if the value at that index is NaN, using `pd.isna()`. This effectively filters out non-NaN indices, leaving only the indices of NaNs.

## Summary/Discussion

• Method 1: Pandas `isna()` with `where()`. Strengths: Native to pandas, readable, and convenient. Weaknesses: Dependent on pandas, not suitable for native Python lists.
• Method 2: List Comprehension with `math.isnan()`. Strengths: Versatile and straightforward, works outside pandas. Weaknesses: Can raise type errors if non-float values are present.
• Method 3: NumPy’s `argwhere()` with `isnan()`. Strengths: Efficient with NumPy’s optimized operations. Weaknesses: Requires conversion to NumPy array, added dependency on the NumPy library.
• Method 4: Pandas Boolean Masking. Strengths: Clean and idiomatic for pandas users. Weaknesses: Limited to pandas data structures.
• Method 5: Using `filter()` with `pd.isna()`. Strengths: Pythonic one-liner, clear intent. Weaknesses: May be less intuitive for those new to functional programming paradigms.
```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Using isna() to find NaN values and then getting their indices
nan_indices = series.isna().where(lambda x: x).dropna().index.tolist()

print(nan_indices)```

Output:

`[1, 3]`

This code first marks all NaN values as `True` using `isna()`, then filters to keep only those `True` values using `where()`. Finally, it removes all non-existent entries (if any) with `dropna()` and collects the indices into a list.

## Method 2: Using List Comprehension with `math.isnan()`

If you’re not working within the pandas framework, you can use Python’s `math` library in conjunction with a list comprehension to identify NaN values. This method is suitable for any iterable and does not require pandas, making it versatile for use with lists and other sequences.

Here’s an example:

```import math

# A non-pandas series (list)
series = [2, np.nan, 5, np.nan, 7]

# Using list comprehension with math.isnan() to find indices of NaNs
nan_indices = [index for index, value in enumerate(series) if math.isnan(value)]

print(nan_indices)```

Output:

`[1, 3]`

This snippet loops through the series with `enumerate()`, which yields both the index and value. It then uses `math.isnan()` to check for NaN and keep the index if the value is NaN. It’s a concise method but requires caution with types since `math.isnan()` won’t handle non-float values.

## Method 3: Using NumPy’s `argwhere()` Combined with `isnan()`

NumPy provides a function `isnan()` which, like pandas’ `isna()`, returns a boolean array. However, by combining this with `argwhere()`, you get the indices directly as a NumPy array. This approach is efficient and makes use of NumPy’s optimized operations.

Here’s an example:

```import numpy as np

# Creating a NumPy array with NaN values
array = np.array([2, np.nan, 5, np.nan, 7])

# Using NumPy's isnan() along with argwhere() to find indices of NaNs
nan_indices = np.argwhere(np.isnan(array)).flatten()

print(nan_indices)```

Output:

`[1 3]`

The code utilizes NumPy’s `isnan()` to find NaNs in the array, then `argwhere()` to extract their positions. The resulting array is flattened to get a one-dimensional array of indices.

## Method 4: Using Pandas `index` with Boolean Masking

Another pandas-centric method employs boolean masking directly to the series’ `index` property. This takes advantage of the fact that pandas indexes can be used to filter series and dataframes just like arrays.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Applying boolean masking to get indices of NaN values
nan_indices = series.index[series.isna()]

print(nan_indices.tolist())```

Output:

`[1, 3]`

Here, `series.isna()` creates a boolean mask, and when applied to `series.index`, it delivers the indices of NaNs. This method is straightforward and idiomatic when working with pandas.

## Bonus One-Liner Method 5: Using `filter()` with `pd.isna()`

A concise one-liner that uses Python’s built-in `filter()` function combined with `pd.isna()` can yield NaN indices without the need for explicit loops or comprehensions. This is a Pythonic way to handle this search and reads nicely in code.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# One-liner using filter() and pd.isna()
nan_indices = list(filter(lambda idx: pd.isna(series[idx]), range(len(series))))

print(nan_indices)```

Output:

`[1, 3]`

This approach uses `filter()` to iterate over each index and applies `lambda` to check if the value at that index is NaN, using `pd.isna()`. This effectively filters out non-NaN indices, leaving only the indices of NaNs.

## Summary/Discussion

• Method 1: Pandas `isna()` with `where()`. Strengths: Native to pandas, readable, and convenient. Weaknesses: Dependent on pandas, not suitable for native Python lists.
• Method 2: List Comprehension with `math.isnan()`. Strengths: Versatile and straightforward, works outside pandas. Weaknesses: Can raise type errors if non-float values are present.
• Method 3: NumPy’s `argwhere()` with `isnan()`. Strengths: Efficient with NumPy’s optimized operations. Weaknesses: Requires conversion to NumPy array, added dependency on the NumPy library.
• Method 4: Pandas Boolean Masking. Strengths: Clean and idiomatic for pandas users. Weaknesses: Limited to pandas data structures.
• Method 5: Using `filter()` with `pd.isna()`. Strengths: Pythonic one-liner, clear intent. Weaknesses: May be less intuitive for those new to functional programming paradigms.
```import numpy as np

# Creating a NumPy array with NaN values
array = np.array([2, np.nan, 5, np.nan, 7])

# Using NumPy's isnan() along with argwhere() to find indices of NaNs
nan_indices = np.argwhere(np.isnan(array)).flatten()

print(nan_indices)```

Output:

`[1 3]`

The code utilizes NumPy’s `isnan()` to find NaNs in the array, then `argwhere()` to extract their positions. The resulting array is flattened to get a one-dimensional array of indices.

## Method 4: Using Pandas `index` with Boolean Masking

Another pandas-centric method employs boolean masking directly to the series’ `index` property. This takes advantage of the fact that pandas indexes can be used to filter series and dataframes just like arrays.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Applying boolean masking to get indices of NaN values
nan_indices = series.index[series.isna()]

print(nan_indices.tolist())```

Output:

`[1, 3]`

Here, `series.isna()` creates a boolean mask, and when applied to `series.index`, it delivers the indices of NaNs. This method is straightforward and idiomatic when working with pandas.

## Bonus One-Liner Method 5: Using `filter()` with `pd.isna()`

A concise one-liner that uses Python’s built-in `filter()` function combined with `pd.isna()` can yield NaN indices without the need for explicit loops or comprehensions. This is a Pythonic way to handle this search and reads nicely in code.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# One-liner using filter() and pd.isna()
nan_indices = list(filter(lambda idx: pd.isna(series[idx]), range(len(series))))

print(nan_indices)```

Output:

`[1, 3]`

This approach uses `filter()` to iterate over each index and applies `lambda` to check if the value at that index is NaN, using `pd.isna()`. This effectively filters out non-NaN indices, leaving only the indices of NaNs.

## Summary/Discussion

• Method 1: Pandas `isna()` with `where()`. Strengths: Native to pandas, readable, and convenient. Weaknesses: Dependent on pandas, not suitable for native Python lists.
• Method 2: List Comprehension with `math.isnan()`. Strengths: Versatile and straightforward, works outside pandas. Weaknesses: Can raise type errors if non-float values are present.
• Method 3: NumPy’s `argwhere()` with `isnan()`. Strengths: Efficient with NumPy’s optimized operations. Weaknesses: Requires conversion to NumPy array, added dependency on the NumPy library.
• Method 4: Pandas Boolean Masking. Strengths: Clean and idiomatic for pandas users. Weaknesses: Limited to pandas data structures.
• Method 5: Using `filter()` with `pd.isna()`. Strengths: Pythonic one-liner, clear intent. Weaknesses: May be less intuitive for those new to functional programming paradigms.
```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Using isna() to find NaN values and then getting their indices
nan_indices = series.isna().where(lambda x: x).dropna().index.tolist()

print(nan_indices)```

Output:

`[1, 3]`

This code first marks all NaN values as `True` using `isna()`, then filters to keep only those `True` values using `where()`. Finally, it removes all non-existent entries (if any) with `dropna()` and collects the indices into a list.

## Method 2: Using List Comprehension with `math.isnan()`

If you’re not working within the pandas framework, you can use Python’s `math` library in conjunction with a list comprehension to identify NaN values. This method is suitable for any iterable and does not require pandas, making it versatile for use with lists and other sequences.

Here’s an example:

```import math

# A non-pandas series (list)
series = [2, np.nan, 5, np.nan, 7]

# Using list comprehension with math.isnan() to find indices of NaNs
nan_indices = [index for index, value in enumerate(series) if math.isnan(value)]

print(nan_indices)```

Output:

`[1, 3]`

This snippet loops through the series with `enumerate()`, which yields both the index and value. It then uses `math.isnan()` to check for NaN and keep the index if the value is NaN. It’s a concise method but requires caution with types since `math.isnan()` won’t handle non-float values.

## Method 3: Using NumPy’s `argwhere()` Combined with `isnan()`

NumPy provides a function `isnan()` which, like pandas’ `isna()`, returns a boolean array. However, by combining this with `argwhere()`, you get the indices directly as a NumPy array. This approach is efficient and makes use of NumPy’s optimized operations.

Here’s an example:

```import numpy as np

# Creating a NumPy array with NaN values
array = np.array([2, np.nan, 5, np.nan, 7])

# Using NumPy's isnan() along with argwhere() to find indices of NaNs
nan_indices = np.argwhere(np.isnan(array)).flatten()

print(nan_indices)```

Output:

`[1 3]`

The code utilizes NumPy’s `isnan()` to find NaNs in the array, then `argwhere()` to extract their positions. The resulting array is flattened to get a one-dimensional array of indices.

## Method 4: Using Pandas `index` with Boolean Masking

Another pandas-centric method employs boolean masking directly to the series’ `index` property. This takes advantage of the fact that pandas indexes can be used to filter series and dataframes just like arrays.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Applying boolean masking to get indices of NaN values
nan_indices = series.index[series.isna()]

print(nan_indices.tolist())```

Output:

`[1, 3]`

Here, `series.isna()` creates a boolean mask, and when applied to `series.index`, it delivers the indices of NaNs. This method is straightforward and idiomatic when working with pandas.

## Bonus One-Liner Method 5: Using `filter()` with `pd.isna()`

A concise one-liner that uses Python’s built-in `filter()` function combined with `pd.isna()` can yield NaN indices without the need for explicit loops or comprehensions. This is a Pythonic way to handle this search and reads nicely in code.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# One-liner using filter() and pd.isna()
nan_indices = list(filter(lambda idx: pd.isna(series[idx]), range(len(series))))

print(nan_indices)```

Output:

`[1, 3]`

This approach uses `filter()` to iterate over each index and applies `lambda` to check if the value at that index is NaN, using `pd.isna()`. This effectively filters out non-NaN indices, leaving only the indices of NaNs.

## Summary/Discussion

• Method 1: Pandas `isna()` with `where()`. Strengths: Native to pandas, readable, and convenient. Weaknesses: Dependent on pandas, not suitable for native Python lists.
• Method 2: List Comprehension with `math.isnan()`. Strengths: Versatile and straightforward, works outside pandas. Weaknesses: Can raise type errors if non-float values are present.
• Method 3: NumPy’s `argwhere()` with `isnan()`. Strengths: Efficient with NumPy’s optimized operations. Weaknesses: Requires conversion to NumPy array, added dependency on the NumPy library.
• Method 4: Pandas Boolean Masking. Strengths: Clean and idiomatic for pandas users. Weaknesses: Limited to pandas data structures.
• Method 5: Using `filter()` with `pd.isna()`. Strengths: Pythonic one-liner, clear intent. Weaknesses: May be less intuitive for those new to functional programming paradigms.
```import math

# A non-pandas series (list)
series = [2, np.nan, 5, np.nan, 7]

# Using list comprehension with math.isnan() to find indices of NaNs
nan_indices = [index for index, value in enumerate(series) if math.isnan(value)]

print(nan_indices)```

Output:

`[1, 3]`

This snippet loops through the series with `enumerate()`, which yields both the index and value. It then uses `math.isnan()` to check for NaN and keep the index if the value is NaN. It’s a concise method but requires caution with types since `math.isnan()` won’t handle non-float values.

## Method 3: Using NumPy’s `argwhere()` Combined with `isnan()`

NumPy provides a function `isnan()` which, like pandas’ `isna()`, returns a boolean array. However, by combining this with `argwhere()`, you get the indices directly as a NumPy array. This approach is efficient and makes use of NumPy’s optimized operations.

Here’s an example:

```import numpy as np

# Creating a NumPy array with NaN values
array = np.array([2, np.nan, 5, np.nan, 7])

# Using NumPy's isnan() along with argwhere() to find indices of NaNs
nan_indices = np.argwhere(np.isnan(array)).flatten()

print(nan_indices)```

Output:

`[1 3]`

The code utilizes NumPy’s `isnan()` to find NaNs in the array, then `argwhere()` to extract their positions. The resulting array is flattened to get a one-dimensional array of indices.

## Method 4: Using Pandas `index` with Boolean Masking

Another pandas-centric method employs boolean masking directly to the series’ `index` property. This takes advantage of the fact that pandas indexes can be used to filter series and dataframes just like arrays.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Applying boolean masking to get indices of NaN values
nan_indices = series.index[series.isna()]

print(nan_indices.tolist())```

Output:

`[1, 3]`

Here, `series.isna()` creates a boolean mask, and when applied to `series.index`, it delivers the indices of NaNs. This method is straightforward and idiomatic when working with pandas.

## Bonus One-Liner Method 5: Using `filter()` with `pd.isna()`

A concise one-liner that uses Python’s built-in `filter()` function combined with `pd.isna()` can yield NaN indices without the need for explicit loops or comprehensions. This is a Pythonic way to handle this search and reads nicely in code.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# One-liner using filter() and pd.isna()
nan_indices = list(filter(lambda idx: pd.isna(series[idx]), range(len(series))))

print(nan_indices)```

Output:

`[1, 3]`

This approach uses `filter()` to iterate over each index and applies `lambda` to check if the value at that index is NaN, using `pd.isna()`. This effectively filters out non-NaN indices, leaving only the indices of NaNs.

## Summary/Discussion

• Method 1: Pandas `isna()` with `where()`. Strengths: Native to pandas, readable, and convenient. Weaknesses: Dependent on pandas, not suitable for native Python lists.
• Method 2: List Comprehension with `math.isnan()`. Strengths: Versatile and straightforward, works outside pandas. Weaknesses: Can raise type errors if non-float values are present.
• Method 3: NumPy’s `argwhere()` with `isnan()`. Strengths: Efficient with NumPy’s optimized operations. Weaknesses: Requires conversion to NumPy array, added dependency on the NumPy library.
• Method 4: Pandas Boolean Masking. Strengths: Clean and idiomatic for pandas users. Weaknesses: Limited to pandas data structures.
• Method 5: Using `filter()` with `pd.isna()`. Strengths: Pythonic one-liner, clear intent. Weaknesses: May be less intuitive for those new to functional programming paradigms.
```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Using isna() to find NaN values and then getting their indices
nan_indices = series.isna().where(lambda x: x).dropna().index.tolist()

print(nan_indices)```

Output:

`[1, 3]`

This code first marks all NaN values as `True` using `isna()`, then filters to keep only those `True` values using `where()`. Finally, it removes all non-existent entries (if any) with `dropna()` and collects the indices into a list.

## Method 2: Using List Comprehension with `math.isnan()`

If you’re not working within the pandas framework, you can use Python’s `math` library in conjunction with a list comprehension to identify NaN values. This method is suitable for any iterable and does not require pandas, making it versatile for use with lists and other sequences.

Here’s an example:

```import math

# A non-pandas series (list)
series = [2, np.nan, 5, np.nan, 7]

# Using list comprehension with math.isnan() to find indices of NaNs
nan_indices = [index for index, value in enumerate(series) if math.isnan(value)]

print(nan_indices)```

Output:

`[1, 3]`

This snippet loops through the series with `enumerate()`, which yields both the index and value. It then uses `math.isnan()` to check for NaN and keep the index if the value is NaN. It’s a concise method but requires caution with types since `math.isnan()` won’t handle non-float values.

## Method 3: Using NumPy’s `argwhere()` Combined with `isnan()`

NumPy provides a function `isnan()` which, like pandas’ `isna()`, returns a boolean array. However, by combining this with `argwhere()`, you get the indices directly as a NumPy array. This approach is efficient and makes use of NumPy’s optimized operations.

Here’s an example:

```import numpy as np

# Creating a NumPy array with NaN values
array = np.array([2, np.nan, 5, np.nan, 7])

# Using NumPy's isnan() along with argwhere() to find indices of NaNs
nan_indices = np.argwhere(np.isnan(array)).flatten()

print(nan_indices)```

Output:

`[1 3]`

The code utilizes NumPy’s `isnan()` to find NaNs in the array, then `argwhere()` to extract their positions. The resulting array is flattened to get a one-dimensional array of indices.

## Method 4: Using Pandas `index` with Boolean Masking

Another pandas-centric method employs boolean masking directly to the series’ `index` property. This takes advantage of the fact that pandas indexes can be used to filter series and dataframes just like arrays.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Applying boolean masking to get indices of NaN values
nan_indices = series.index[series.isna()]

print(nan_indices.tolist())```

Output:

`[1, 3]`

Here, `series.isna()` creates a boolean mask, and when applied to `series.index`, it delivers the indices of NaNs. This method is straightforward and idiomatic when working with pandas.

## Bonus One-Liner Method 5: Using `filter()` with `pd.isna()`

A concise one-liner that uses Python’s built-in `filter()` function combined with `pd.isna()` can yield NaN indices without the need for explicit loops or comprehensions. This is a Pythonic way to handle this search and reads nicely in code.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# One-liner using filter() and pd.isna()
nan_indices = list(filter(lambda idx: pd.isna(series[idx]), range(len(series))))

print(nan_indices)```

Output:

`[1, 3]`

This approach uses `filter()` to iterate over each index and applies `lambda` to check if the value at that index is NaN, using `pd.isna()`. This effectively filters out non-NaN indices, leaving only the indices of NaNs.

## Summary/Discussion

• Method 1: Pandas `isna()` with `where()`. Strengths: Native to pandas, readable, and convenient. Weaknesses: Dependent on pandas, not suitable for native Python lists.
• Method 2: List Comprehension with `math.isnan()`. Strengths: Versatile and straightforward, works outside pandas. Weaknesses: Can raise type errors if non-float values are present.
• Method 3: NumPy’s `argwhere()` with `isnan()`. Strengths: Efficient with NumPy’s optimized operations. Weaknesses: Requires conversion to NumPy array, added dependency on the NumPy library.
• Method 4: Pandas Boolean Masking. Strengths: Clean and idiomatic for pandas users. Weaknesses: Limited to pandas data structures.
• Method 5: Using `filter()` with `pd.isna()`. Strengths: Pythonic one-liner, clear intent. Weaknesses: May be less intuitive for those new to functional programming paradigms.
```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Applying boolean masking to get indices of NaN values
nan_indices = series.index[series.isna()]

print(nan_indices.tolist())```

Output:

`[1, 3]`

Here, `series.isna()` creates a boolean mask, and when applied to `series.index`, it delivers the indices of NaNs. This method is straightforward and idiomatic when working with pandas.

## Bonus One-Liner Method 5: Using `filter()` with `pd.isna()`

A concise one-liner that uses Python’s built-in `filter()` function combined with `pd.isna()` can yield NaN indices without the need for explicit loops or comprehensions. This is a Pythonic way to handle this search and reads nicely in code.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# One-liner using filter() and pd.isna()
nan_indices = list(filter(lambda idx: pd.isna(series[idx]), range(len(series))))

print(nan_indices)```

Output:

`[1, 3]`

This approach uses `filter()` to iterate over each index and applies `lambda` to check if the value at that index is NaN, using `pd.isna()`. This effectively filters out non-NaN indices, leaving only the indices of NaNs.

## Summary/Discussion

• Method 1: Pandas `isna()` with `where()`. Strengths: Native to pandas, readable, and convenient. Weaknesses: Dependent on pandas, not suitable for native Python lists.
• Method 2: List Comprehension with `math.isnan()`. Strengths: Versatile and straightforward, works outside pandas. Weaknesses: Can raise type errors if non-float values are present.
• Method 3: NumPy’s `argwhere()` with `isnan()`. Strengths: Efficient with NumPy’s optimized operations. Weaknesses: Requires conversion to NumPy array, added dependency on the NumPy library.
• Method 4: Pandas Boolean Masking. Strengths: Clean and idiomatic for pandas users. Weaknesses: Limited to pandas data structures.
• Method 5: Using `filter()` with `pd.isna()`. Strengths: Pythonic one-liner, clear intent. Weaknesses: May be less intuitive for those new to functional programming paradigms.
```import math

# A non-pandas series (list)
series = [2, np.nan, 5, np.nan, 7]

# Using list comprehension with math.isnan() to find indices of NaNs
nan_indices = [index for index, value in enumerate(series) if math.isnan(value)]

print(nan_indices)```

Output:

`[1, 3]`

This snippet loops through the series with `enumerate()`, which yields both the index and value. It then uses `math.isnan()` to check for NaN and keep the index if the value is NaN. It’s a concise method but requires caution with types since `math.isnan()` won’t handle non-float values.

## Method 3: Using NumPy’s `argwhere()` Combined with `isnan()`

NumPy provides a function `isnan()` which, like pandas’ `isna()`, returns a boolean array. However, by combining this with `argwhere()`, you get the indices directly as a NumPy array. This approach is efficient and makes use of NumPy’s optimized operations.

Here’s an example:

```import numpy as np

# Creating a NumPy array with NaN values
array = np.array([2, np.nan, 5, np.nan, 7])

# Using NumPy's isnan() along with argwhere() to find indices of NaNs
nan_indices = np.argwhere(np.isnan(array)).flatten()

print(nan_indices)```

Output:

`[1 3]`

The code utilizes NumPy’s `isnan()` to find NaNs in the array, then `argwhere()` to extract their positions. The resulting array is flattened to get a one-dimensional array of indices.

## Method 4: Using Pandas `index` with Boolean Masking

Another pandas-centric method employs boolean masking directly to the series’ `index` property. This takes advantage of the fact that pandas indexes can be used to filter series and dataframes just like arrays.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Applying boolean masking to get indices of NaN values
nan_indices = series.index[series.isna()]

print(nan_indices.tolist())```

Output:

`[1, 3]`

Here, `series.isna()` creates a boolean mask, and when applied to `series.index`, it delivers the indices of NaNs. This method is straightforward and idiomatic when working with pandas.

## Bonus One-Liner Method 5: Using `filter()` with `pd.isna()`

A concise one-liner that uses Python’s built-in `filter()` function combined with `pd.isna()` can yield NaN indices without the need for explicit loops or comprehensions. This is a Pythonic way to handle this search and reads nicely in code.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# One-liner using filter() and pd.isna()
nan_indices = list(filter(lambda idx: pd.isna(series[idx]), range(len(series))))

print(nan_indices)```

Output:

`[1, 3]`

This approach uses `filter()` to iterate over each index and applies `lambda` to check if the value at that index is NaN, using `pd.isna()`. This effectively filters out non-NaN indices, leaving only the indices of NaNs.

## Summary/Discussion

• Method 1: Pandas `isna()` with `where()`. Strengths: Native to pandas, readable, and convenient. Weaknesses: Dependent on pandas, not suitable for native Python lists.
• Method 2: List Comprehension with `math.isnan()`. Strengths: Versatile and straightforward, works outside pandas. Weaknesses: Can raise type errors if non-float values are present.
• Method 3: NumPy’s `argwhere()` with `isnan()`. Strengths: Efficient with NumPy’s optimized operations. Weaknesses: Requires conversion to NumPy array, added dependency on the NumPy library.
• Method 4: Pandas Boolean Masking. Strengths: Clean and idiomatic for pandas users. Weaknesses: Limited to pandas data structures.
• Method 5: Using `filter()` with `pd.isna()`. Strengths: Pythonic one-liner, clear intent. Weaknesses: May be less intuitive for those new to functional programming paradigms.
```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Using isna() to find NaN values and then getting their indices
nan_indices = series.isna().where(lambda x: x).dropna().index.tolist()

print(nan_indices)```

Output:

`[1, 3]`

This code first marks all NaN values as `True` using `isna()`, then filters to keep only those `True` values using `where()`. Finally, it removes all non-existent entries (if any) with `dropna()` and collects the indices into a list.

## Method 2: Using List Comprehension with `math.isnan()`

If you’re not working within the pandas framework, you can use Python’s `math` library in conjunction with a list comprehension to identify NaN values. This method is suitable for any iterable and does not require pandas, making it versatile for use with lists and other sequences.

Here’s an example:

```import math

# A non-pandas series (list)
series = [2, np.nan, 5, np.nan, 7]

# Using list comprehension with math.isnan() to find indices of NaNs
nan_indices = [index for index, value in enumerate(series) if math.isnan(value)]

print(nan_indices)```

Output:

`[1, 3]`

This snippet loops through the series with `enumerate()`, which yields both the index and value. It then uses `math.isnan()` to check for NaN and keep the index if the value is NaN. It’s a concise method but requires caution with types since `math.isnan()` won’t handle non-float values.

## Method 3: Using NumPy’s `argwhere()` Combined with `isnan()`

NumPy provides a function `isnan()` which, like pandas’ `isna()`, returns a boolean array. However, by combining this with `argwhere()`, you get the indices directly as a NumPy array. This approach is efficient and makes use of NumPy’s optimized operations.

Here’s an example:

```import numpy as np

# Creating a NumPy array with NaN values
array = np.array([2, np.nan, 5, np.nan, 7])

# Using NumPy's isnan() along with argwhere() to find indices of NaNs
nan_indices = np.argwhere(np.isnan(array)).flatten()

print(nan_indices)```

Output:

`[1 3]`

The code utilizes NumPy’s `isnan()` to find NaNs in the array, then `argwhere()` to extract their positions. The resulting array is flattened to get a one-dimensional array of indices.

## Method 4: Using Pandas `index` with Boolean Masking

Another pandas-centric method employs boolean masking directly to the series’ `index` property. This takes advantage of the fact that pandas indexes can be used to filter series and dataframes just like arrays.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Applying boolean masking to get indices of NaN values
nan_indices = series.index[series.isna()]

print(nan_indices.tolist())```

Output:

`[1, 3]`

Here, `series.isna()` creates a boolean mask, and when applied to `series.index`, it delivers the indices of NaNs. This method is straightforward and idiomatic when working with pandas.

## Bonus One-Liner Method 5: Using `filter()` with `pd.isna()`

A concise one-liner that uses Python’s built-in `filter()` function combined with `pd.isna()` can yield NaN indices without the need for explicit loops or comprehensions. This is a Pythonic way to handle this search and reads nicely in code.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# One-liner using filter() and pd.isna()
nan_indices = list(filter(lambda idx: pd.isna(series[idx]), range(len(series))))

print(nan_indices)```

Output:

`[1, 3]`

This approach uses `filter()` to iterate over each index and applies `lambda` to check if the value at that index is NaN, using `pd.isna()`. This effectively filters out non-NaN indices, leaving only the indices of NaNs.

## Summary/Discussion

• Method 1: Pandas `isna()` with `where()`. Strengths: Native to pandas, readable, and convenient. Weaknesses: Dependent on pandas, not suitable for native Python lists.
• Method 2: List Comprehension with `math.isnan()`. Strengths: Versatile and straightforward, works outside pandas. Weaknesses: Can raise type errors if non-float values are present.
• Method 3: NumPy’s `argwhere()` with `isnan()`. Strengths: Efficient with NumPy’s optimized operations. Weaknesses: Requires conversion to NumPy array, added dependency on the NumPy library.
• Method 4: Pandas Boolean Masking. Strengths: Clean and idiomatic for pandas users. Weaknesses: Limited to pandas data structures.
• Method 5: Using `filter()` with `pd.isna()`. Strengths: Pythonic one-liner, clear intent. Weaknesses: May be less intuitive for those new to functional programming paradigms.
```import numpy as np

# Creating a NumPy array with NaN values
array = np.array([2, np.nan, 5, np.nan, 7])

# Using NumPy's isnan() along with argwhere() to find indices of NaNs
nan_indices = np.argwhere(np.isnan(array)).flatten()

print(nan_indices)```

Output:

`[1 3]`

The code utilizes NumPy’s `isnan()` to find NaNs in the array, then `argwhere()` to extract their positions. The resulting array is flattened to get a one-dimensional array of indices.

## Method 4: Using Pandas `index` with Boolean Masking

Another pandas-centric method employs boolean masking directly to the series’ `index` property. This takes advantage of the fact that pandas indexes can be used to filter series and dataframes just like arrays.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Applying boolean masking to get indices of NaN values
nan_indices = series.index[series.isna()]

print(nan_indices.tolist())```

Output:

`[1, 3]`

Here, `series.isna()` creates a boolean mask, and when applied to `series.index`, it delivers the indices of NaNs. This method is straightforward and idiomatic when working with pandas.

## Bonus One-Liner Method 5: Using `filter()` with `pd.isna()`

A concise one-liner that uses Python’s built-in `filter()` function combined with `pd.isna()` can yield NaN indices without the need for explicit loops or comprehensions. This is a Pythonic way to handle this search and reads nicely in code.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# One-liner using filter() and pd.isna()
nan_indices = list(filter(lambda idx: pd.isna(series[idx]), range(len(series))))

print(nan_indices)```

Output:

`[1, 3]`

This approach uses `filter()` to iterate over each index and applies `lambda` to check if the value at that index is NaN, using `pd.isna()`. This effectively filters out non-NaN indices, leaving only the indices of NaNs.

## Summary/Discussion

• Method 1: Pandas `isna()` with `where()`. Strengths: Native to pandas, readable, and convenient. Weaknesses: Dependent on pandas, not suitable for native Python lists.
• Method 2: List Comprehension with `math.isnan()`. Strengths: Versatile and straightforward, works outside pandas. Weaknesses: Can raise type errors if non-float values are present.
• Method 3: NumPy’s `argwhere()` with `isnan()`. Strengths: Efficient with NumPy’s optimized operations. Weaknesses: Requires conversion to NumPy array, added dependency on the NumPy library.
• Method 4: Pandas Boolean Masking. Strengths: Clean and idiomatic for pandas users. Weaknesses: Limited to pandas data structures.
• Method 5: Using `filter()` with `pd.isna()`. Strengths: Pythonic one-liner, clear intent. Weaknesses: May be less intuitive for those new to functional programming paradigms.
```import math

# A non-pandas series (list)
series = [2, np.nan, 5, np.nan, 7]

# Using list comprehension with math.isnan() to find indices of NaNs
nan_indices = [index for index, value in enumerate(series) if math.isnan(value)]

print(nan_indices)```

Output:

`[1, 3]`

This snippet loops through the series with `enumerate()`, which yields both the index and value. It then uses `math.isnan()` to check for NaN and keep the index if the value is NaN. It’s a concise method but requires caution with types since `math.isnan()` won’t handle non-float values.

## Method 3: Using NumPy’s `argwhere()` Combined with `isnan()`

NumPy provides a function `isnan()` which, like pandas’ `isna()`, returns a boolean array. However, by combining this with `argwhere()`, you get the indices directly as a NumPy array. This approach is efficient and makes use of NumPy’s optimized operations.

Here’s an example:

```import numpy as np

# Creating a NumPy array with NaN values
array = np.array([2, np.nan, 5, np.nan, 7])

# Using NumPy's isnan() along with argwhere() to find indices of NaNs
nan_indices = np.argwhere(np.isnan(array)).flatten()

print(nan_indices)```

Output:

`[1 3]`

The code utilizes NumPy’s `isnan()` to find NaNs in the array, then `argwhere()` to extract their positions. The resulting array is flattened to get a one-dimensional array of indices.

## Method 4: Using Pandas `index` with Boolean Masking

Another pandas-centric method employs boolean masking directly to the series’ `index` property. This takes advantage of the fact that pandas indexes can be used to filter series and dataframes just like arrays.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Applying boolean masking to get indices of NaN values
nan_indices = series.index[series.isna()]

print(nan_indices.tolist())```

Output:

`[1, 3]`

Here, `series.isna()` creates a boolean mask, and when applied to `series.index`, it delivers the indices of NaNs. This method is straightforward and idiomatic when working with pandas.

## Bonus One-Liner Method 5: Using `filter()` with `pd.isna()`

A concise one-liner that uses Python’s built-in `filter()` function combined with `pd.isna()` can yield NaN indices without the need for explicit loops or comprehensions. This is a Pythonic way to handle this search and reads nicely in code.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# One-liner using filter() and pd.isna()
nan_indices = list(filter(lambda idx: pd.isna(series[idx]), range(len(series))))

print(nan_indices)```

Output:

`[1, 3]`

This approach uses `filter()` to iterate over each index and applies `lambda` to check if the value at that index is NaN, using `pd.isna()`. This effectively filters out non-NaN indices, leaving only the indices of NaNs.

## Summary/Discussion

• Method 1: Pandas `isna()` with `where()`. Strengths: Native to pandas, readable, and convenient. Weaknesses: Dependent on pandas, not suitable for native Python lists.
• Method 2: List Comprehension with `math.isnan()`. Strengths: Versatile and straightforward, works outside pandas. Weaknesses: Can raise type errors if non-float values are present.
• Method 3: NumPy’s `argwhere()` with `isnan()`. Strengths: Efficient with NumPy’s optimized operations. Weaknesses: Requires conversion to NumPy array, added dependency on the NumPy library.
• Method 4: Pandas Boolean Masking. Strengths: Clean and idiomatic for pandas users. Weaknesses: Limited to pandas data structures.
• Method 5: Using `filter()` with `pd.isna()`. Strengths: Pythonic one-liner, clear intent. Weaknesses: May be less intuitive for those new to functional programming paradigms.
```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Using isna() to find NaN values and then getting their indices
nan_indices = series.isna().where(lambda x: x).dropna().index.tolist()

print(nan_indices)```

Output:

`[1, 3]`

This code first marks all NaN values as `True` using `isna()`, then filters to keep only those `True` values using `where()`. Finally, it removes all non-existent entries (if any) with `dropna()` and collects the indices into a list.

## Method 2: Using List Comprehension with `math.isnan()`

If you’re not working within the pandas framework, you can use Python’s `math` library in conjunction with a list comprehension to identify NaN values. This method is suitable for any iterable and does not require pandas, making it versatile for use with lists and other sequences.

Here’s an example:

```import math

# A non-pandas series (list)
series = [2, np.nan, 5, np.nan, 7]

# Using list comprehension with math.isnan() to find indices of NaNs
nan_indices = [index for index, value in enumerate(series) if math.isnan(value)]

print(nan_indices)```

Output:

`[1, 3]`

This snippet loops through the series with `enumerate()`, which yields both the index and value. It then uses `math.isnan()` to check for NaN and keep the index if the value is NaN. It’s a concise method but requires caution with types since `math.isnan()` won’t handle non-float values.

## Method 3: Using NumPy’s `argwhere()` Combined with `isnan()`

NumPy provides a function `isnan()` which, like pandas’ `isna()`, returns a boolean array. However, by combining this with `argwhere()`, you get the indices directly as a NumPy array. This approach is efficient and makes use of NumPy’s optimized operations.

Here’s an example:

```import numpy as np

# Creating a NumPy array with NaN values
array = np.array([2, np.nan, 5, np.nan, 7])

# Using NumPy's isnan() along with argwhere() to find indices of NaNs
nan_indices = np.argwhere(np.isnan(array)).flatten()

print(nan_indices)```

Output:

`[1 3]`

The code utilizes NumPy’s `isnan()` to find NaNs in the array, then `argwhere()` to extract their positions. The resulting array is flattened to get a one-dimensional array of indices.

## Method 4: Using Pandas `index` with Boolean Masking

Another pandas-centric method employs boolean masking directly to the series’ `index` property. This takes advantage of the fact that pandas indexes can be used to filter series and dataframes just like arrays.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Applying boolean masking to get indices of NaN values
nan_indices = series.index[series.isna()]

print(nan_indices.tolist())```

Output:

`[1, 3]`

Here, `series.isna()` creates a boolean mask, and when applied to `series.index`, it delivers the indices of NaNs. This method is straightforward and idiomatic when working with pandas.

## Bonus One-Liner Method 5: Using `filter()` with `pd.isna()`

A concise one-liner that uses Python’s built-in `filter()` function combined with `pd.isna()` can yield NaN indices without the need for explicit loops or comprehensions. This is a Pythonic way to handle this search and reads nicely in code.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# One-liner using filter() and pd.isna()
nan_indices = list(filter(lambda idx: pd.isna(series[idx]), range(len(series))))

print(nan_indices)```

Output:

`[1, 3]`

This approach uses `filter()` to iterate over each index and applies `lambda` to check if the value at that index is NaN, using `pd.isna()`. This effectively filters out non-NaN indices, leaving only the indices of NaNs.

## Summary/Discussion

• Method 1: Pandas `isna()` with `where()`. Strengths: Native to pandas, readable, and convenient. Weaknesses: Dependent on pandas, not suitable for native Python lists.
• Method 2: List Comprehension with `math.isnan()`. Strengths: Versatile and straightforward, works outside pandas. Weaknesses: Can raise type errors if non-float values are present.
• Method 3: NumPy’s `argwhere()` with `isnan()`. Strengths: Efficient with NumPy’s optimized operations. Weaknesses: Requires conversion to NumPy array, added dependency on the NumPy library.
• Method 4: Pandas Boolean Masking. Strengths: Clean and idiomatic for pandas users. Weaknesses: Limited to pandas data structures.
• Method 5: Using `filter()` with `pd.isna()`. Strengths: Pythonic one-liner, clear intent. Weaknesses: May be less intuitive for those new to functional programming paradigms.
```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Applying boolean masking to get indices of NaN values
nan_indices = series.index[series.isna()]

print(nan_indices.tolist())```

Output:

`[1, 3]`

Here, `series.isna()` creates a boolean mask, and when applied to `series.index`, it delivers the indices of NaNs. This method is straightforward and idiomatic when working with pandas.

## Bonus One-Liner Method 5: Using `filter()` with `pd.isna()`

A concise one-liner that uses Python’s built-in `filter()` function combined with `pd.isna()` can yield NaN indices without the need for explicit loops or comprehensions. This is a Pythonic way to handle this search and reads nicely in code.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# One-liner using filter() and pd.isna()
nan_indices = list(filter(lambda idx: pd.isna(series[idx]), range(len(series))))

print(nan_indices)```

Output:

`[1, 3]`

This approach uses `filter()` to iterate over each index and applies `lambda` to check if the value at that index is NaN, using `pd.isna()`. This effectively filters out non-NaN indices, leaving only the indices of NaNs.

## Summary/Discussion

• Method 1: Pandas `isna()` with `where()`. Strengths: Native to pandas, readable, and convenient. Weaknesses: Dependent on pandas, not suitable for native Python lists.
• Method 2: List Comprehension with `math.isnan()`. Strengths: Versatile and straightforward, works outside pandas. Weaknesses: Can raise type errors if non-float values are present.
• Method 3: NumPy’s `argwhere()` with `isnan()`. Strengths: Efficient with NumPy’s optimized operations. Weaknesses: Requires conversion to NumPy array, added dependency on the NumPy library.
• Method 4: Pandas Boolean Masking. Strengths: Clean and idiomatic for pandas users. Weaknesses: Limited to pandas data structures.
• Method 5: Using `filter()` with `pd.isna()`. Strengths: Pythonic one-liner, clear intent. Weaknesses: May be less intuitive for those new to functional programming paradigms.
```import numpy as np

# Creating a NumPy array with NaN values
array = np.array([2, np.nan, 5, np.nan, 7])

# Using NumPy's isnan() along with argwhere() to find indices of NaNs
nan_indices = np.argwhere(np.isnan(array)).flatten()

print(nan_indices)```

Output:

`[1 3]`

The code utilizes NumPy’s `isnan()` to find NaNs in the array, then `argwhere()` to extract their positions. The resulting array is flattened to get a one-dimensional array of indices.

## Method 4: Using Pandas `index` with Boolean Masking

Another pandas-centric method employs boolean masking directly to the series’ `index` property. This takes advantage of the fact that pandas indexes can be used to filter series and dataframes just like arrays.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Applying boolean masking to get indices of NaN values
nan_indices = series.index[series.isna()]

print(nan_indices.tolist())```

Output:

`[1, 3]`

Here, `series.isna()` creates a boolean mask, and when applied to `series.index`, it delivers the indices of NaNs. This method is straightforward and idiomatic when working with pandas.

## Bonus One-Liner Method 5: Using `filter()` with `pd.isna()`

A concise one-liner that uses Python’s built-in `filter()` function combined with `pd.isna()` can yield NaN indices without the need for explicit loops or comprehensions. This is a Pythonic way to handle this search and reads nicely in code.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# One-liner using filter() and pd.isna()
nan_indices = list(filter(lambda idx: pd.isna(series[idx]), range(len(series))))

print(nan_indices)```

Output:

`[1, 3]`

This approach uses `filter()` to iterate over each index and applies `lambda` to check if the value at that index is NaN, using `pd.isna()`. This effectively filters out non-NaN indices, leaving only the indices of NaNs.

## Summary/Discussion

• Method 1: Pandas `isna()` with `where()`. Strengths: Native to pandas, readable, and convenient. Weaknesses: Dependent on pandas, not suitable for native Python lists.
• Method 2: List Comprehension with `math.isnan()`. Strengths: Versatile and straightforward, works outside pandas. Weaknesses: Can raise type errors if non-float values are present.
• Method 3: NumPy’s `argwhere()` with `isnan()`. Strengths: Efficient with NumPy’s optimized operations. Weaknesses: Requires conversion to NumPy array, added dependency on the NumPy library.
• Method 4: Pandas Boolean Masking. Strengths: Clean and idiomatic for pandas users. Weaknesses: Limited to pandas data structures.
• Method 5: Using `filter()` with `pd.isna()`. Strengths: Pythonic one-liner, clear intent. Weaknesses: May be less intuitive for those new to functional programming paradigms.
```import math

# A non-pandas series (list)
series = [2, np.nan, 5, np.nan, 7]

# Using list comprehension with math.isnan() to find indices of NaNs
nan_indices = [index for index, value in enumerate(series) if math.isnan(value)]

print(nan_indices)```

Output:

`[1, 3]`

This snippet loops through the series with `enumerate()`, which yields both the index and value. It then uses `math.isnan()` to check for NaN and keep the index if the value is NaN. It’s a concise method but requires caution with types since `math.isnan()` won’t handle non-float values.

## Method 3: Using NumPy’s `argwhere()` Combined with `isnan()`

NumPy provides a function `isnan()` which, like pandas’ `isna()`, returns a boolean array. However, by combining this with `argwhere()`, you get the indices directly as a NumPy array. This approach is efficient and makes use of NumPy’s optimized operations.

Here’s an example:

```import numpy as np

# Creating a NumPy array with NaN values
array = np.array([2, np.nan, 5, np.nan, 7])

# Using NumPy's isnan() along with argwhere() to find indices of NaNs
nan_indices = np.argwhere(np.isnan(array)).flatten()

print(nan_indices)```

Output:

`[1 3]`

The code utilizes NumPy’s `isnan()` to find NaNs in the array, then `argwhere()` to extract their positions. The resulting array is flattened to get a one-dimensional array of indices.

## Method 4: Using Pandas `index` with Boolean Masking

Another pandas-centric method employs boolean masking directly to the series’ `index` property. This takes advantage of the fact that pandas indexes can be used to filter series and dataframes just like arrays.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Applying boolean masking to get indices of NaN values
nan_indices = series.index[series.isna()]

print(nan_indices.tolist())```

Output:

`[1, 3]`

Here, `series.isna()` creates a boolean mask, and when applied to `series.index`, it delivers the indices of NaNs. This method is straightforward and idiomatic when working with pandas.

## Bonus One-Liner Method 5: Using `filter()` with `pd.isna()`

A concise one-liner that uses Python’s built-in `filter()` function combined with `pd.isna()` can yield NaN indices without the need for explicit loops or comprehensions. This is a Pythonic way to handle this search and reads nicely in code.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# One-liner using filter() and pd.isna()
nan_indices = list(filter(lambda idx: pd.isna(series[idx]), range(len(series))))

print(nan_indices)```

Output:

`[1, 3]`

This approach uses `filter()` to iterate over each index and applies `lambda` to check if the value at that index is NaN, using `pd.isna()`. This effectively filters out non-NaN indices, leaving only the indices of NaNs.

## Summary/Discussion

• Method 1: Pandas `isna()` with `where()`. Strengths: Native to pandas, readable, and convenient. Weaknesses: Dependent on pandas, not suitable for native Python lists.
• Method 2: List Comprehension with `math.isnan()`. Strengths: Versatile and straightforward, works outside pandas. Weaknesses: Can raise type errors if non-float values are present.
• Method 3: NumPy’s `argwhere()` with `isnan()`. Strengths: Efficient with NumPy’s optimized operations. Weaknesses: Requires conversion to NumPy array, added dependency on the NumPy library.
• Method 4: Pandas Boolean Masking. Strengths: Clean and idiomatic for pandas users. Weaknesses: Limited to pandas data structures.
• Method 5: Using `filter()` with `pd.isna()`. Strengths: Pythonic one-liner, clear intent. Weaknesses: May be less intuitive for those new to functional programming paradigms.
```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Using isna() to find NaN values and then getting their indices
nan_indices = series.isna().where(lambda x: x).dropna().index.tolist()

print(nan_indices)```

Output:

`[1, 3]`

This code first marks all NaN values as `True` using `isna()`, then filters to keep only those `True` values using `where()`. Finally, it removes all non-existent entries (if any) with `dropna()` and collects the indices into a list.

## Method 2: Using List Comprehension with `math.isnan()`

If you’re not working within the pandas framework, you can use Python’s `math` library in conjunction with a list comprehension to identify NaN values. This method is suitable for any iterable and does not require pandas, making it versatile for use with lists and other sequences.

Here’s an example:

```import math

# A non-pandas series (list)
series = [2, np.nan, 5, np.nan, 7]

# Using list comprehension with math.isnan() to find indices of NaNs
nan_indices = [index for index, value in enumerate(series) if math.isnan(value)]

print(nan_indices)```

Output:

`[1, 3]`

This snippet loops through the series with `enumerate()`, which yields both the index and value. It then uses `math.isnan()` to check for NaN and keep the index if the value is NaN. It’s a concise method but requires caution with types since `math.isnan()` won’t handle non-float values.

## Method 3: Using NumPy’s `argwhere()` Combined with `isnan()`

NumPy provides a function `isnan()` which, like pandas’ `isna()`, returns a boolean array. However, by combining this with `argwhere()`, you get the indices directly as a NumPy array. This approach is efficient and makes use of NumPy’s optimized operations.

Here’s an example:

```import numpy as np

# Creating a NumPy array with NaN values
array = np.array([2, np.nan, 5, np.nan, 7])

# Using NumPy's isnan() along with argwhere() to find indices of NaNs
nan_indices = np.argwhere(np.isnan(array)).flatten()

print(nan_indices)```

Output:

`[1 3]`

The code utilizes NumPy’s `isnan()` to find NaNs in the array, then `argwhere()` to extract their positions. The resulting array is flattened to get a one-dimensional array of indices.

## Method 4: Using Pandas `index` with Boolean Masking

Another pandas-centric method employs boolean masking directly to the series’ `index` property. This takes advantage of the fact that pandas indexes can be used to filter series and dataframes just like arrays.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# Applying boolean masking to get indices of NaN values
nan_indices = series.index[series.isna()]

print(nan_indices.tolist())```

Output:

`[1, 3]`

Here, `series.isna()` creates a boolean mask, and when applied to `series.index`, it delivers the indices of NaNs. This method is straightforward and idiomatic when working with pandas.

## Bonus One-Liner Method 5: Using `filter()` with `pd.isna()`

A concise one-liner that uses Python’s built-in `filter()` function combined with `pd.isna()` can yield NaN indices without the need for explicit loops or comprehensions. This is a Pythonic way to handle this search and reads nicely in code.

Here’s an example:

```import pandas as pd
import numpy as np

# Creating a pandas Series with NaN values
series = pd.Series([2, np.nan, 5, np.nan, 7])

# One-liner using filter() and pd.isna()
nan_indices = list(filter(lambda idx: pd.isna(series[idx]), range(len(series))))

print(nan_indices)```

Output:

`[1, 3]`

This approach uses `filter()` to iterate over each index and applies `lambda` to check if the value at that index is NaN, using `pd.isna()`. This effectively filters out non-NaN indices, leaving only the indices of NaNs.

## Summary/Discussion

• Method 1: Pandas `isna()` with `where()`. Strengths: Native to pandas, readable, and convenient. Weaknesses: Dependent on pandas, not suitable for native Python lists.
• Method 2: List Comprehension with `math.isnan()`. Strengths: Versatile and straightforward, works outside pandas. Weaknesses: Can raise type errors if non-float values are present.
• Method 3: NumPy’s `argwhere()` with `isnan()`. Strengths: Efficient with NumPy’s optimized operations. Weaknesses: Requires conversion to NumPy array, added dependency on the NumPy library.
• Method 4: Pandas Boolean Masking. Strengths: Clean and idiomatic for pandas users. Weaknesses: Limited to pandas data structures.
• Method 5: Using `filter()` with `pd.isna()`. Strengths: Pythonic one-liner, clear intent. Weaknesses: May be less intuitive for those new to functional programming paradigms.