Pandas Series count() Function

In Pandas, the count() function is used to count the number of non-null elements in a Series. It effectively provides a count of the observations or data points that have valid values, excluding any null values (NaN). This function is particularly useful for assessing data completeness and identifying missing or incomplete data in a dataset.

In this article, I will explain the count() function by using its syntax, parameters, usage and how we can return an integer representing the number of non-null elements in the Series. This count excludes any null values (NaN).

Key Points –

The count() function is used to count the number of non-NA/null entries in a Series.
It returns an integer representing the number of non-null elements in the Series.
Null values (NaN) are not counted when using the count() function.
The function can also be used to count elements based on specific conditions using boolean indexing.
The count of a Series can be useful in data preprocessing and cleaning tasks to identify missing or incomplete data.

Pandas Series count() Introduction

Following is the syntax of the pandas Series count() function.


# Syntax of series count()
Series.count()

Parameters of the Series count()

This function doesn’t take any parameters. It’s called directly on a Pandas Series object to count the number of non-null elements within that Series.

Return Value

It returns an integer representing the count of non-null elements in the Series.

Counting Non-Null Elements in a Series

To count the non-null elements in a Pandas Series, you can use the count() function directly on the Series object.

Now, let’s create a Pandas Series from a Python list.


import pandas as pd

# Create Pandas Series
data = [2, 4, None, 6, None, 8]
series = pd.Series(data)
print("Original Series:\n",series)

Output:

Here, you use the count() function on the series object to count the non-null elements. The count() function returns the number of non-null elements in the Series, excluding any NaN (Not a Number) values.


# Count the non-null elements in the Series
count = series.count()
print("Number of non-null elements in the Series:", count)

In the above example, the count() function returns 4 because there are 4 non-null elements in the Series. The null values (None) are not counted. This example yields the below output

Alternatively, to count the non-zero elements in a Pandas Series, you can use boolean indexing combined with the sum() function.


import pandas as pd

# Create a sample Series
data = pd.Series([0, 1, 3, 5, 0, 7, 0])

# Count the non-zero elements in the Series
count_non_zero = (data != 0).sum()
print("Number of non-zero elements in the Series:", count_non_zero)

# Output:
# Number of non-zero elements in the Series: 4

In the above example, the expression (data != 0) creates a boolean mask that True indicates non-zero values. Then, sum() is used to count the number of True values in the mask, corresponding to the number of non-zero elements in the Series.

Counting String Occurrences

To count occurrences of specific string values in a Pandas Series, you can use boolean indexing to filter the elements equal to the target string and then apply thesum() function to count the occurrences.


import pandas as pd

# Create a sample Series
data = pd.Series(['Spark', 'MongoDB', 'MongoDB', 'Spark', 'Pandas', 'MongoDB'])

# Count the occurrences of a specific string, e.g., 'MongoDB'
target_string = 'MongoDB'
count_occurrences = (data == target_string).sum()
print(f"Number of occurrences of '{target_string}': {count_occurrences}")

# Output:
# Number of occurrences of 'MongoDB': 3

In the above example, the expression (data == target_string) creates a boolean mask where True indicates elements equal to MongoDB. Then, sum() is used to count the number of True values in the mask, which corresponds to the number of occurrences of the target string in the Series.

Counting Unique Elements in a Series

Similarly, to count the number of unique elements in a Pandas Series, you can use the nunique() function. For instance, the nunique() function returns the count of unique elements in the Series, which is 3 in this case (Spark, MongoDB, and Pandas).


import pandas as pd

# Create a sample Series
data = pd.Series(['Spark', 'MongoDB', 'MongoDB', 'Spark', 'Pandas', 'MongoDB'])

# Count the number of unique elements in the Series
count_unique = data.nunique()
print("Number of unique elements in the Series:", count_unique)

# Output:
# Number of unique elements in the Series: 3

Counting Elements in a Series Based on Index Labels

You can also count elements in a Pandas Series based on specific index labels, you can use the loc[] accessor along with the count() function.


import pandas as pd

# Create a sample Series with custom index labels
data = pd.Series([10, 20, 30, 40, 50], index=['a', 'b', 'c', 'd', 'e'])

# Count elements with specific index labels
result = data.loc[['a', 'c', 'e']].count()
print("Number of elements with index labels 'a', 'c', and 'e':", result)

# Output:
# Number of elements with index labels 'a', 'c', and 'e': 3

In the above example, the loc[[a, c, e]] is used to select elements with index labels a, c, and e. Then, the count() function is applied to count the number of non-null elements among these selected elements.

Counting Boolean Values

Counting boolean values in a Pandas Series involves using the sum() function with boolean indexing or directly passing the boolean Series to the sum() function.

You can use boolean indexing to filter the Series based on the boolean condition and then apply the sum() function to count the True values.


import pandas as pd

# Create a Series of boolean values
ser = pd.Series([True, False, True, True, False, True])

# Count True values using boolean indexing
count_true = ser[ser == True].count()
print("Count of True values:", count_true)

# Output:
# Count of True values: 4

You can directly pass the boolean Series to the sum() function, which will interpret True as 1 and False as 0, effectively counting the True values.


# Count True values using direct sum
count_true = ser.sum()
print("Count of True values:", count_true)

# Output:
# Count of True values: 4

FAQ on Pandas Series count() Function

The count() function in Pandas Series is used to count the number of non-null (non-NA) entries in the Series. This means it provides the count of valid data points, excluding any entries that are NaN (null) or missing. This function is particularly useful for quickly determining how many valid (non-missing) values are present in a dataset.

The count() function in Pandas Series handles null values (represented as NaN – Not a Number) by excluding them from the count. This means that when you call count() on a Pandas Series, it returns the number of non-null elements within the Series.

The count() function in Pandas Series can be used with mixed data types. It counts the number of non-null elements regardless of their data types.

The count() function can also be used on a DataFrame, where it returns the count of non-null values for each column. For a Series, the syntax is Series.count(). For a DataFrame, the syntax is DataFrame.count().

Conclusion

In this article, I have explained the count() function in Pandas Series is a fundamental tool for assessing data completeness by providing the count of non-null elements within the Series. This function excludes null values (NaN), making it particularly useful for data preprocessing tasks, such as identifying and handling missing or incomplete data with examples.

Happy Learning!!

References

https://pandas.pydata.org/docs/reference/api/pandas.Series.count.html