7 C
Thursday, November 16, 2023

7 Important Information High quality Checks with Pandas

7 Essential Data Quality Checks with Pandas
Picture by Creator


As an information skilled, you’re in all probability conversant in the price of poor information high quality. For all information initiatives—large or small—you need to carry out important information high quality checks.

There are devoted libraries and frameworks for information high quality evaluation. However if you’re a newbie, you possibly can run easy but vital information high quality checks with pandas. And this tutorial will train you the way.

We’ll use the California Housing Dataset from scikit-learn for this tutorial.



We’ll use the California housing dataset from Scikit-learn’s datasets module. The info set comprises over 20,000 information of eight numeric options and a goal median home worth.

Let’s learn the dataset right into a pandas dataframe df:

from sklearn.datasets import fetch_california_housing
import pandas as pd

# Fetch the California housing dataset
information = fetch_california_housing()

# Convert the dataset to a Pandas DataFrame
df = pd.DataFrame(information.information, columns=information.feature_names)

# Add goal column
df['MedHouseVal'] = information.goal


For an in depth description of the dataset, run information.DESCR as proven:


7 Essential Data Quality Checks with Pandas
Output of information.DESCR


Let’s get some fundamental info on the dataset:


Right here’s the output:

Output >>>

RangeIndex: 20640 entries, 0 to 20639
Information columns (whole 9 columns):
 #   Column   	Non-Null Rely  Dtype  
---  ------   	--------------  -----  
 0   MedInc   	20640 non-null  float64
 1   HouseAge 	20640 non-null  float64
 2   AveRooms 	20640 non-null  float64
 3   AveBedrms	20640 non-null  float64
 4   Inhabitants   20640 non-null  float64
 5   AveOccup 	20640 non-null  float64
 6   Latitude 	20640 non-null  float64
 7   Longitude	20640 non-null  float64
 8   MedHouseVal  20640 non-null  float64
dtypes: float64(9)
reminiscence utilization: 1.4 MB


As a result of we have now numeric options, allow us to additionally get the abstract begins utilizing the describe() methodology:


7 Essential Data Quality Checks with Pandas
Output of df.describe()



Actual-world datasets usually have lacking values. To research the information and construct fashions, you’ll want to deal with these lacking values.

To make sure information high quality, you need to test if the fraction of lacking values is inside a particular tolerance restrict. You’ll be able to then impute the lacking values utilizing appropriate imputation methods.

Step one, due to this fact, is to test for lacking values throughout all options within the dataset.

This code checks for lacking values in every column of the dataframe df

# Verify for lacking values within the DataFrame
missing_values = df.isnull().sum()
print("Lacking Values:")


The result’s a pandas collection that reveals the rely of lacking values for every column:

Output >>>

Lacking Values:
MedInc     	0
HouseAge   	0
AveRooms   	0
AveBedrms  	0
Inhabitants 	0
AveOccup   	0
Latitude   	0
Longitude  	0
MedHouseVal	0
dtype: int64


As seen, there aren’t any lacking values on this dataset.



Duplicate information within the dataset can skew evaluation. So you need to test for and drop the duplicate information as wanted.

Right here’s the code to determine and return duplicate rows in df. If there are any duplicate rows, they are going to be included within the consequence:

# Verify for duplicate rows within the DataFrame
duplicate_rows = df[df.duplicated()]
print("Duplicate Rows:")


The result’s an empty dataframe. That means there aren’t any duplicate information within the dataset:

Output >>>

Duplicate Rows:
Empty DataFrame
Columns: [MedInc, HouseAge, AveRooms, AveBedrms, Population, AveOccup, Latitude, Longitude, MedHouseVal]
Index: []



When analyzing a dataset, you’ll usually have to rework or scale a number of options. To keep away from surprising errors when performing such operations, you will need to test if the columns are the entire anticipated information kind.

This code checks the information sorts of every column within the dataframe df:

# Verify information sorts of every column within the DataFrame
data_types = df.dtypes
print("Information Varieties:")


Right here, all numeric options are of float information kind as anticipated:

Output >>>

Information Varieties:
MedInc     	float64
HouseAge   	float64
AveRooms   	float64
AveBedrms  	float64
Inhabitants 	float64
AveOccup   	float64
Latitude   	float64
Longitude  	float64
MedHouseVal	float64
dtype: object



Outliers are information factors which might be considerably totally different from different factors within the dataset. In the event you bear in mind, we ran the describe() methodology on the dataframe.

Based mostly on the quartile values and the utmost worth, you possibly can’ve recognized {that a} subset of options comprise outliers. Particularly, these options:

  • MedInc
  • AveRooms
  • AveBedrms
  • Inhabitants

One strategy to dealing with outliers is to make use of the interquartile vary, the distinction between the seventy fifth and twenty fifth quartiles. If Q1 is the twenty fifth quartile and Q3 is the seventy fifth quartile, then the interquartile vary is given by: Q3 – Q1. 

We then use the quartiles and the IQR to outline the interval [Q1 - 1.5 * IQR, Q3 + 1.5 * IQR]. And all factors exterior this vary are outliers.

columns_to_check = ['MedInc', 'AveRooms', 'AveBedrms', 'Population']

# Operate to seek out information with outliers
def find_outliers_pandas(information, column):
	Q1 = information[column].quantile(0.25)
	Q3 = information[column].quantile(0.75)
	IQR = Q3 - Q1
	lower_bound = Q1 - 1.5 * IQR
	upper_bound = Q3 + 1.5 * IQR
	outliers = information[(data[column] < lower_bound) | (information[column] > upper_bound)]
	return outliers

# Discover information with outliers for every specified column
outliers_dict = {}

for column in columns_to-check:
	outliers_dict[column] = find_outliers_pandas(df, column)

# Print the information with outliers for every column
for column, outliers in outliers_dict.gadgets():
	print(f"Outliers in '{column}':")


7 Essential Data Quality Checks with Pandas
Outliers in ‘AveRooms’ Column | Truncated Output for Outliers Verify



An vital test for numeric options is to validate the vary. This ensures that each one observations of a characteristic tackle values in an anticipated vary.

This code validates that the ‘MedInc’ worth falls inside an anticipated vary and identifies information factors that don’t meet this standards:

# Verify numerical worth vary for the 'MedInc' column
valid_range = (0, 16)  
value_range_check = df[~df['MedInc'].between(*valid_range)]
print("Worth Vary Verify (MedInc):")


You’ll be able to attempt for different numeric options of your alternative. However we see that each one values within the ‘MedInc’ column lie within the anticipated vary:

Output >>>

Worth Vary Verify (MedInc):
Empty DataFrame
Columns: [MedInc, HouseAge, AveRooms, AveBedrms, Population, AveOccup, Latitude, Longitude, MedHouseVal]
Index: []



Most information units comprise associated options. So it is vital to incorporate checks primarily based on logically related relationships between columns (or options).

Whereas options—individually—might tackle values within the anticipated vary, the connection between them could also be inconsistent.

Right here is an instance for our dataset. In a legitimate report, the ‘AveRooms’ ought to usually be larger than or equal to the ‘AveBedRms’.

# AveRooms shouldn't be smaller than AveBedrooms
invalid_data = df[df['AveRooms'] < df['AveBedrms']]
print("Invalid Information (AveRooms < AveBedrms):")


Within the California housing dataset we’re working with, we see that there aren’t any such invalid information:

Output >>>

Invalid Information (AveRooms < AveBedrms):
Empty DataFrame
Columns: [MedInc, HouseAge, AveRooms, AveBedrms, Population, AveOccup, Latitude, Longitude, MedHouseVal]
Index: []



Inconsistent information entry is a typical information high quality situation in most datasets. Examples embrace:

  • Inconsistent formatting in datetime columns 
  • Inconsistent logging of categorical variable values 
  • Recording of studying in several models 

In our dataset, we’ve verified the information sorts of columns and have recognized outliers. However you can too run checks for inconsistent information entry.

Let’s whip up a easy instance to test if all of the date entries have a constant formatting.

Right here we use common expressions together with pandas apply() operate to test if all date entries are within the YYYY-MM-DD format:

import pandas as pd
import re

information = {'Date': ['2023-10-29', '2023-11-15', '23-10-2023', '2023/10/29', '2023-10-30']}
df = pd.DataFrame(information)

# Outline the anticipated date format
date_format_pattern = r'^d{4}-d{2}-d{2}$'  # YYYY-MM-DD format

# Operate to test if a date worth matches the anticipated format
def check_date_format(date_str, date_format_pattern):
	return re.match(date_format_pattern, date_str) is just not None

# Apply the format test to the 'Date' column
date_format_check = df['Date'].apply(lambda x: check_date_format(x, date_format_pattern))

# Establish and retrieve entries that don't observe the anticipated format
non_adherent_dates = df[~date_format_check]

if not non_adherent_dates.empty:
	print("Entries that don't observe the anticipated format:")
	print("All dates are within the anticipated format.")


This returns the entries that don’t observe the anticipated format:

Output >>>

Entries that don't observe the anticipated format:
2  23-10-2023
3  2023/10/29



On this tutorial, we went over frequent information high quality checks with pandas. 

If you end up engaged on smaller information evaluation initiatives, these information high quality checks with pandas are a very good place to begin. Relying on the issue and the dataset, you possibly can embrace further checks. 

In the event you’re enthusiastic about studying information evaluation, take a look at the information 7 Steps to Mastering Information Wrangling with Pandas and Python.

Bala Priya C is a developer and technical author from India. She likes working on the intersection of math, programming, information science, and content material creation. Her areas of curiosity and experience embrace DevOps, information science, and pure language processing. She enjoys studying, writing, coding, and occasional! At present, she’s engaged on studying and sharing her data with the developer group by authoring tutorials, how-to guides, opinion items, and extra.

Latest news
Related news


Please enter your comment!
Please enter your name here