## Counting Duplicates in Pandas DataFrame

Pandas is a popular data manipulation library designed for data analysis in Python. It provides numerous functionalities that allow data manipulation, filtering, and sorting of data with relative ease.

One of the functionalities that pandas offer is counting duplicates in a DataFrame. In this article, we will explore different ways of counting duplicates in a pandas DataFrame using different methods.

## Counting duplicates under a single DataFrame column

Counting duplicates under a single column of a DataFrame is one of the fundamental operations that can be performed easily using pandas. To count duplicates under a single DataFrame column, we use the groupby function.

For instance, to count duplicates under a single column ‘column_name’, we write:

`df['column_name'].value_counts()`

The value_counts() function returns a pandas Series object with the count of each unique value in the ‘column_name’ column. In this way, we can perform count-based operations under a single column and use the result for analysis.

## Counting duplicates across multiple columns

In some cases, we may need to count duplicates across multiple columns in a DataFrame. To do this, we use the pandas groupby function by passing a list of columns.

For example, suppose we want to count duplicates under two columns ‘column_name_1’ and ‘column_name_2’. In that case, we write:

`df.groupby(['column_name_1', 'column_name_2']).size().reset_index(name='counts')`

Here, we use the groupby function to group the data based on two columns ‘column_name_1’ and ‘column_name_2’.

The size() function returns the count of each unique value in the grouped data, and finally, the reset_index() function reindexes the DataFrame and adds a new ‘counts’ column with the count of each unique combination of values.

## Counting duplicates when having NaN values in the DataFrame

In some cases, our DataFrame may have NaN values. NaN values refer to missing or undefined values in a dataset.

NaN values must be considered while performing count-based operations. We can ignore NaN values while performing count-based operations; pandas provides an optional argument ‘dropna’ for this purpose.

By default, ‘dropna’ is set to true, which excludes NaN while performing operations. We can set it to false to include NaN in the count-based operations.

For instance, suppose we want to count duplicates under a single column ‘column_name’, including NaN values. In that case, we write:

`df['column_name'].value_counts(dropna=False)`

### Using df.pivot_table() to Count Duplicates

The pivot_table function is another powerful function available in pandas to perform operations, including counting duplicates.

The pivot_table function allows us to summarize a DataFrame by grouping data by one or more columns, providing insights into the dataset’s values’ distribution.to using df.pivot_table() function

The pivot_table function is a useful tool to summarize our dataset. The function takes arguments: index, columns, values, and aggfunc.

The index specifies the column or columns to group the data. The columns determine the column or columns of the returned DataFrame.

The values column(s) list explicitly which column(s) to aggregate. Finally, the aggfunc is the aggregation function to use for the groupby.

### Using df.pivot_table() to count duplicates under a single DataFrame column

To count duplicates under a single column of a DataFrame, we can use the pivot_table function by setting the index to the column name and values to the count function. For instance, suppose we want to count duplicates under a single column ‘column_name’.

In that case, we write:

`df.pivot_table(index=['column_name'], aggfunc='size')`

The size() function returns a pandas Series object with the count of each unique value in the ‘column_name’ column. The pivot_table function groups this data by the ‘column_name’ column, and finally, we obtain the count of each unique value.

### Using df.pivot_table() to count duplicates across multiple columns

Similar to groupby, the pivot_table function can be used to count duplicates across multiple columns. To count duplicates across multiple columns, we use the pivot_table function with an additional argument ‘columns’ set to the list of column names.

For instance, suppose we want to count duplicates under two columns ‘column_name_1’ and ‘column_name_2’. In that case, we write:

`df.pivot_table(index=['column_name_1'], columns='column_name_2', aggfunc='size', fill_value=0)`

Here, the index argument is the column to group data, columns are the columns to separate, aggfunc is the counting function to use, and ‘fill_value’ is used to fill any NaN values.

### Using df.pivot_table() to count duplicates when having NaN values in the DataFrame

The pivot_table function also has an additional parameter to handle NaN values. The parameter ‘dropna’ can be set to false to include NaN values.

For instance, suppose we want to count duplicates under a single column ‘column_name’, including NaN values. In that case, we write:

`df.pivot_table(index=['column_name'], aggfunc='size', dropna=False)`

## Conclusion

In this article, we have explored different ways of counting duplicates in a pandas DataFrame. We have demonstrated how to count duplicates under a single column, multiple columns, and how to handle NaN values while performing these operations.

Finally, we have introduced the pivot_table function and explored how it can be used to perform count-based operations using pandas.

## Counting Duplicates in Pandas DataFrame: Examples

In the previous article, we explored different ways of counting duplicates in a pandas DataFrame. In this article, we will provide practical examples of how to implement these counting methods using different scenarios.

### Example 1: Counting duplicates under a single DataFrame column

Suppose we have a DataFrame with a single column ‘subject’ containing students’ subjects and their corresponding grades.

```
df = pd.DataFrame({
'subject': ['Math', 'English', 'Science', 'Math', 'History', 'Science', 'English', 'Math', 'History'],
'grade': [90, 85, 92, 85, 76, 92, 88, 85, 79]
})
```

We can count duplicates under the ‘subject’ column using the value_counts() function as follows:

```
subject_count = df['subject'].value_counts()
print(subject_count)
```

This returns a pandas Series object with the count of each unique value in the ‘subject’ column:

```
Math 3
English 2
Science 2
History 2
Name: subject, dtype: int64
```

We can see that there are three duplicates under the ‘Math’ subject as it appears three times in the ‘subject’ column, while the other subjects have two duplicates each.

### Example 2: Counting duplicates across multiple columns

Suppose we have a DataFrame with two columns ‘subject’ and ‘grade,’ which contains students’ subjects and their corresponding grades.

```
df = pd.DataFrame({
'subject': ['Math', 'Math', 'Science', 'Science', 'History', 'History'],
'grade': [90, 85, 92, 90, 76, 85],
'name': ['John', 'Sara', 'Tom', 'Mike', 'Lisa', 'Mia']
})
```

Suppose we want to count duplicates under two columns ‘subject’ and ‘grade.’ In that case, we use the groupby function by passing a list of columns:

```
subject_grade_count = df.groupby(['subject', 'grade']).size().reset_index(name='counts')
print(subject_grade_count)
```

Here we used the groupby function to group the data based on two columns ‘subject’ and ‘grade.’ The size() function returns the count of each unique value in the grouped data, and finally, the reset_index() function reindexes the DataFrame and adds a new ‘counts’ column with the count of each unique combination of values:

```
subject grade counts
0 History 76 1
1 History 85 1
2 Math 85 1
3 Math 90 1
4 Science 90 1
5 Science 92 1
```

Here we can see that there are no duplicates under the ‘subject’ and ‘grade’ columns as each unique combination appears only once.

### Example 3: Counting duplicates when having NaN values in the DataFrame

Suppose we have a DataFrame with two columns ‘subject’ and ‘grade,’ which contains students’ subjects and their corresponding grades, and some columns with NaN values:

```
df = pd.DataFrame({
'subject': ['Math', 'Math', 'Science', np.nan, 'History', 'History'],
'grade': [90, 85, np.nan, 90, 76, 85]
})
```

We can count duplicates under the ‘subject’ column, including NaN values, using the value_counts() function as follows:

```
subject_count = df['subject'].value_counts(dropna=False)
print(subject_count)
```

Here, we use the ‘dropna’ argument of the value_counts() function to account for NaN values. This returns a pandas Series object with the count of each unique value in the ‘subject’ column and includes NaN values:

```
subject counts
0 Math 2
1 History 2
2 Science 1
3 NaN 1
```

We can see that there is one NaN value under the ‘subject’ column, which indicates a missing value. By setting the ‘dropna’ argument to False, we can account for such missing values.

## Conclusion

In conclusion, pandas provides a wide range of functionalities to manipulate, analyze, and summarize data. We have explored different ways to perform count-based operations using pandas, including counting duplicates under a single column, across multiple columns, and how to handle NaN values.

By providing practical examples, we can understand how to implement these counting methods in different scenarios and develop the necessary skills to manipulate and analyze data using pandas.

In this article, we have delved into the different methods to count duplicates in a pandas DataFrame, including counting duplicates under a single column, across multiple columns, and handling NaN values.

Using practical examples, we have covered how to implement these counting methods, ranging from using the pandas value_counts() function to the groupby and pivot_table functions. The ability to count duplicates is a fundamental data manipulation skill that is crucial in data analysis and research.

By mastering these methods, data analysts can uncover hidden insights and patterns within large datasets.