## Unlocking the Mysteries of Pandas DataFrame: How to Calculate Average Row Values and the Percentage of Nan Values

Do you ever find yourself needing to calculate the average row values or the percentage of missing data in a Pandas DataFrame? If so, you are not alone.

Many data analysts and scientists routinely perform these calculations to gain insights into their data. In this article, we will explore two different approaches to calculating average row values and the percentage of missing data.

## Calculating Average Row Values for Selected Columns in a Pandas DataFrame

### Method 1: Calculate Average Row Value for All Columns

The first approach to calculating the average row value for a Pandas DataFrame involves calculating the mean for all columns. This method is useful when you want to get a general sense of the dataset’s trends.

To calculate the average row value for all columns, you can use the `df.mean()`

function and specify `axis=1`

to calculate the mean for each row:

`df['average_all'] = df.mean(axis=1)`

In this example, the new column “average_all” is created, and the mean value for each row is calculated and added to this column.

### Method 2: Calculate Average Row Value for Specific Columns

The second approach involves calculating the mean for only specific columns.

This method is useful when you want to focus on specific aspects of the data or when the dataset is large and includes unnecessary columns. To calculate the average row value for specific columns, you can use the `df[['col1', 'col3']].mean()`

function and specify `axis=1`

to calculate the mean for each row:

`df['avg_points_rebounds'] = df[['points', 'rebounds']].mean(axis=1)`

In this example, the new column “avg_points_rebounds” is created, and the mean value for the “points” and “rebounds” columns is calculated and added to this column.

## Example DataFrame:

```
import pandas as pd
data = {'name': ['John', 'Jane', 'Mike', 'Lisa'],
'age': [33, 28, 41, 39],
'points': [20, 18, 15, 19],
'rebounds': [8, 7, 10, 12]}
df = pd.DataFrame(data)
print(df)
```

## Output:

```
name age points rebounds
0 John 33 20 8
1 Jane 28 18 7
2 Mike 41 15 10
3 Lisa 39 19 12
```

## Using Method 1:

```
df['average_all'] = df.mean(axis=1)
print(df)
```

## Output:

```
name age points rebounds average_all
0 John 33 20 8 15.25
1 Jane 28 18 7 13.25
2 Mike 41 15 10 19.00
3 Lisa 39 19 12 22.50
```

## Using Method 2:

```
df['avg_points_rebounds'] = df[['points', 'rebounds']].mean(axis=1)
print(df)
```

## Output:

```
name age points rebounds avg_points_rebounds
0 John 33 20 8 14.0
1 Jane 28 18 7 12.5
2 Mike 41 15 10 12.5
3 Lisa 39 19 12 15.5
```

## Calculating Percentage of Nan Values in a Pandas DataFrame

Before we begin, it’s essential to understand what NaN means. NaN stands for “not a number” and is used to indicate missing or undefined data.

In a Pandas DataFrame, NaN values are represented using `np.nan`

.

## Example DataFrame with Nan Values:

```
import pandas as pd
import numpy as np
data = {'name': ['John', 'Jane', 'Mike', 'Lisa'],
'age': [33, np.nan, 41, 39],
'points': [20, 18, np.nan, 19],
'rebounds': [8, 7, 10, np.nan]}
df = pd.DataFrame(data)
print(df)
```

## Output:

```
name age points rebounds
0 John 33.0 20.0 8.0
1 Jane NaN 18.0 7.0
2 Mike 41.0 NaN 10.0
3 Lisa 39.0 19.0 NaN
```

## Calculate Percentage of Nan Values in a DataFrame

To calculate the percentage of missing values in a Pandas DataFrame, we first need to know the number of missing values and the total number of values in the dataset. We can use the `isnull()`

function to detect the missing values, the `sum()`

function to count them, and the `count()`

function to calculate the total number of values:

```
total_cells = np.product(df.shape)
total_missing = df.isnull().sum().sum()
percentage_missing = (total_missing / total_cells) * 100
print(percentage_missing)
```

## Output:

`25.0`

In this example, we first calculate the total number of cells in the DataFrame by multiplying the number of rows by the number of columns. Then, we count the number of missing values using the `isnull()`

function and `sum()`

function and divide it by the total number of cells to get the percentage of missing values.

## Calculate Percentage of Nan Values in a Specific Column

To calculate the percentage of missing values in a specific column, we can use the `isnull()`

function to identify the missing values and `sum()`

function with `count()`

function to count the total number of values in the selected column:

```
total_cells = df['age'].shape[0]
total_missing = df['age'].isnull().sum()
percentage_missing = (total_missing / total_cells) * 100
print(percentage_missing)
```

## Output:

`25.0`

In this example, we first calculate the total number of cells in the “age” column using the `shape()`

function. Then, we count the number of missing values in the “age” column using the `isnull()`

function and `sum()`

function.

Finally, we divide the total number of missing values by the total number of cells in the selected column to get the percentage of missing values.

## Conclusion

In conclusion, calculating average row values and the percentage of missing values in a Pandas DataFrame is incredibly straightforward. In this article, we have explored two different methods of calculating average row values and how to calculate the percentage of missing values in a DataFrame.

These calculations can provide valuable insights into your data, enabling you to make more informed decisions and better understand your data. So, the next time you are working with a Pandas DataFrame, remember these methods to calculate average row values and the percentage of missing data.

## Replacing Nan Values in a Pandas DataFrame and Dropping Rows or Columns Containing Nan Values

Working with data can be challenging, especially when the data contains missing or NaN values. NaN, which stands for “not a number,” is a special value in Pandas that represents missing or not available data.

Generally, it is essential to either replace the NaN values with a specific value or drop them altogether before analyzing the data. In this article, we will explore how to replace NaN values in a Pandas DataFrame and how to drop rows or columns containing NaN values.

## Replacing NaN Values in a Pandas DataFrame

### Example DataFrame with NaN Values

Before we begin replacing NaN values, let us first create a simple example DataFrame with NaN values.

```
import pandas as pd
import numpy as np
data = {'A': [1, 2, np.nan, 4],
'B': [5, np.nan, 7, 8],
'C': [9, 10, 11, 12]}
df = pd.DataFrame(data)
print(df)
```

## Output:

```
A B C
0 1.0 5.0 9
1 2.0 NaN 10
2 NaN 7.0 11
3 4.0 8.0 12
```

### Replace NaN Values with a Specific Value

You can replace all NaN values in a Pandas DataFrame with a specific value using the `replace()`

method.

```
df.replace(np.nan, 0, inplace=True)
print(df)
```

## Output:

```
A B C
0 1.0 5.0 9
1 2.0 0.0 10
2 0.0 7.0 11
3 4.0 8.0 12
```

In this example, we replaced all of the NaN values in the DataFrame with the value zero.

### Replace NaN Values with the Mean of the Column

It is common to replace missing values with the mean or median value of the column. We can use the `mean()`

function to calculate the mean of a column and the `fillna()`

method to replace all NaN values with the mean.

```
mean = df['B'].mean()
df['B'].fillna(mean, inplace=True)
print(df)
```

## Output:

```
A B C
0 1.0 5.000000 9
1 2.0 6.666667 10
2 NaN 7.000000 11
3 4.0 8.000000 12
```

In this example, we calculated the mean of column ‘B’ and replaced the NaN values of column ‘B’ with the calculated mean.

## Dropping Rows or Columns Containing NaN Values in a Pandas DataFrame

### Example DataFrame with NaN Values

Before we begin dropping rows or columns, let us first create a simple example DataFrame with NaN values.

```
import pandas as pd
import numpy as np
data = {'A': [1, 2, np.nan, 4],
'B': [5, np.nan, 7, 8],
'C': [9, 10, 11, 12]}
df = pd.DataFrame(data)
print(df)
```

## Output:

```
A B C
0 1.0 5.0 9
1 2.0 NaN 10
2 NaN 7.0 11
3 4.0 8.0 12
```

### Dropping Rows Containing NaN Values

We can use the `dropna()`

method to drop all rows that contain NaN values in a Pandas DataFrame.

```
df.dropna(axis=0, inplace=True)
print(df)
```

## Output:

```
A B C
0 1.0 5.0 9
3 4.0 8.0 12
```

In this example, we dropped all rows that contain NaN values from the DataFrame.

### Dropping Columns Containing NaN Values

Similarly, we can use the `dropna()`

method to drop all columns that contain NaN values in a Pandas DataFrame.

```
df.dropna(axis=1, inplace=True)
print(df)
```

## Output:

```
C
0 9
1 10
2 11
3 12
```

In this example, we dropped all columns that contain NaN values from the DataFrame.

## Conclusion

In this article, we have explored how to replace NaN values and how to drop rows or columns containing NaN values in a Pandas DataFrame. Replacing NaN values with a specific value or statistics like mean or median can provide a slightly better representation of the dataset.

Dropping rows or columns containing NaN values can be helpful when it is impossible to impute these values. Understanding these techniques will help you to analyze your data accurately and produce quality results.

## Filtering Rows of a Pandas DataFrame Based on Specific Conditions

When dealing with large datasets, it can be challenging to extract specific information. Filtering rows based on specific conditions is an essential technique for data analysis.

Pandas provides several methods to filter and manipulate data that can help you to identify patterns, trends, and relationships within your data. In this article, we will explore different approaches to filter rows of a Pandas DataFrame based on specific conditions.

## Example DataFrame

Before we start filtering, let’s create a simple example DataFrame to demonstrate each filtering method.

```
import pandas as pd
data = {'Name': ['John', 'Jane', 'Mike', 'Lisa'],
'Age': [28, 33, 41, 39],
'Gender': ['Male', 'Female', 'Male', 'Female'],
'City': ['New York', 'San Francisco', 'London', 'Paris']}
df = pd.DataFrame(data)
print(df)
```

## Output:

```
Name Age Gender City
0 John 28 Male New York
1 Jane 33 Female San Francisco
2 Mike 41 Male London
3 Lisa 39 Female Paris
```

In this example, we have a DataFrame with four columns: Name, Age, Gender, and City. We will use this DataFrame to demonstrate the filtering methods.

## Filter Rows Using a Boolean Condition

One of the simplest ways to filter rows is by applying a boolean condition to a single column. Let’s say we want to filter all rows where the Age is greater than 35.

```
condition = df['Age'] > 35
filtered_df = df.loc[condition]
print(filtered_df)
```

## Output:

```
Name Age Gender City
2 Mike 41 Male London
3 Lisa 39 Female Paris
```

In this example, we first created a boolean condition that checks if the age value is greater than 35 for every row. Then, we used the `loc()`

method and applied the condition to filter the rows that meet that condition.

## Filter Rows Using Multiple Boolean Conditions

Sometimes you may want to filter rows based on multiple boolean conditions. In these cases, you can use the `&`

(and) and `|`

(or) operators to combine the conditions.

Let’s say we want to filter all rows where the Age is greater than 35 and the Gender is Male.

```
condition1 = df['Age'] > 35
condition2 = df['Gender'] == 'Male'
filtered_df = df.loc[condition1 & condition2]
print(filtered_df)
```

## Output:

```
Name Age Gender City
2 Mike 41 Male London
```

In this example, we first created two boolean conditions, `condition1`

and `condition2`

. Then, we used the `&`

operator to combine the two conditions.

Finally, we used the `loc()`

method to filter the rows that meet both conditions.

## Filter Rows Using String Methods

You may also want to filter rows based on string values in a specific column. In these cases, you can use string methods like `str.contains()`

.

Let’s say we want to filter all rows where the City contains the word York.

```
filtered_df = df.loc[df['City'].str.contains('York')]
print(filtered_df)
```

## Output:

```
Name Age Gender City
0 John 28 Male New York
```