## Selecting Rows in a Pandas DataFrame where Two Columns are Equal

Are you struggling to filter out rows in your Pandas DataFrame where two columns are equal? Look no further! In this article, we’ll cover two methods for selecting rows where two columns have equal or not-equal values.

By the end of this article, you’ll have a better understanding of how to manipulate your DataFrame to fit your specific needs.

### Method 1: Select Rows where Two Columns Are Equal

The first method is pretty straightforward.

Suppose you have a DataFrame with columns A and B, and you want to select only those rows where the values of A and B are equal. Here is how you can do it:

```
import pandas as pd
df = pd.DataFrame({'A': [1, 2, 3, 4], 'B': [1, 1, 3, 4], 'C': ['a', 'b', 'c', 'd']})
df_equal = df[df['A'] == df['B']]
```

Let’s try to understand this code step by step. First, we import Pandas and create a DataFrame with the columns A, B, and C.

Next, we create a new DataFrame, df_equal, by selecting only the rows where column A equals column B. It’s important to note that `df['A'] == df['B']`

creates a boolean mask that selects only the rows where the condition is true.

We then use this boolean mask to select the matching rows from the original DataFrame and create a new filtered DataFrame.

### Method 2: Select Rows where Two Columns Are Not Equal

If you want to select all rows where the values of two columns are not equal, you can modify the previous code as follows:

```
df_not_equal = df[df['A'] != df['B']]
```

Here, we change the conditional operator from ‘==’ to ‘!=’.

This operator selects all rows where the values of column A and column B are not equal.

### Example 1: Select Rows where Two Columns Are Equal

Now that you understand how to select rows where two columns are equal or not equal, let’s try an example.

Suppose you have a DataFrame with two columns, A and B, representing the scores of two students in a test:

```
df_scores = pd.DataFrame({'A': [74, 92, 83, 67], 'B': [74, 74, 92, 83]})
```

You want to count the number of rows where the scores of the two students are equal. Here’s how you can do it:

```
n_equal = len(df_scores[df_scores['A'] == df_scores['B']])
```

We first select the rows where the scores are equal, then use the `len()`

method to count the total number of rows that fit this criteria.

## Conclusion

In conclusion, selecting rows in a Pandas DataFrame where two columns are equal or not equal is an important skill to have when working with large datasets. We covered two methods for achieving this task and provided examples to help you understand the process.

With this knowledge, you’ll be able to filter out relevant data from your DataFrame with ease.

### Example 2: Selecting Rows where Two Columns Are Not Equal

In this section, we’ll explore a more detailed example of selecting rows where two columns are not equal.

Suppose you have a DataFrame with three columns: ‘name’, ‘age’, and ‘height’. You want to select those rows where the age and height of an individual are not equal.

Let’s first create a sample DataFrame:

```
import pandas as pd
data = {'name': ['John', 'Jane', 'Alice', 'Bob', 'Chris'],
'age': [25, 30, 25, 27, 29],
'height': [170, 164, 180, 180, 174]}
df = pd.DataFrame(data)
```

Our DataFrame ‘df’ looks like this:

```
name age height
0 John 25 170
1 Jane 30 164
2 Alice 25 180
3 Bob 27 180
4 Chris 29 174
```

Now, let’s select the rows where age and height are not equal. Here’s the code:

```
df_not_equal = df[df['age'] != df['height']]
```

This will select all the rows where the age and height of an individual are not equal.

In our case, it’ll select rows 1 and 4. We can also count the total number of rows where age and height are not equal.

Here’s the code for it:

```
n_not_equal = len(df[df['age'] != df['height']])
```

This will give us the count, which is 2 in our example.

### Selecting Rows where Two Columns Are Not Equal and a Third Column Meets a Criteria

Sometimes, we may want to select rows where two columns are not equal, but only if a third column meets a certain condition. For example, in our sample DataFrame, we may only want to select those rows where age and height are not equal and age is greater than 25.

Here’s how you can do it:

```
df_not_equal_age = df[(df['age'] != df['height']) & (df['age'] > 25)]
```

This code will select only rows 3 and 4, where age and height are not equal and age is greater than 25. It’s important to note the use of the ‘&’ operator in the code.

It’s used to combine the two conditions. If you have multiple conditions, you can use ‘|’ operator to combine them into one condition.

## Conclusion

In this section, we covered an example of selecting rows where two columns are not equal. We saw how we can select all the rows where age and height are not equal and count them.

We also saw how we can add a third condition to our selection to filter out even more rows. With these concepts in mind, you can manipulate your DataFrame to extract specific data and perform more complex data analysis.

In this article, we discussed two methods for selecting rows in a Pandas DataFrame where two columns are either equal or not equal. We provided examples for both cases to help understand the process better.

By using these techniques, we can easily filter out relevant data from the DataFrame quickly. We also saw how a third condition can be added to our selection to filter out more rows.

In conclusion, understanding this fundamental manipulation of data in Pandas can lead to more advanced analysis and a better understanding of the data.