Data visualization is one of the most important skills in Data Science, Machine Learning, Artificial Intelligence, and Business Analytics. Before building a Machine Learning model, data scientists first explore and understand their data through visualizations. Charts and graphs help identify trends, patterns, relationships, outliers, and missing values that are difficult to recognize from tables alone.
Python provides several powerful libraries for creating visualizations, including Matplotlib, Seaborn, Plotly, Bokeh, and Altair. Among these, Matplotlib and Seaborn are the most widely used libraries for Data Science and Machine Learning.
In this lesson, you will learn why data visualization is important, understand the visualization workflow, discover common chart types, and prepare for creating professional charts using Matplotlib and Seaborn.
Data visualization is the process of representing data graphically using charts, graphs, maps, and dashboards. Instead of reading hundreds of rows in a spreadsheet, visualizations allow people to quickly understand information through shapes, colors, and patterns.
For example, instead of reading monthly sales numbers, a line chart immediately shows whether sales are increasing, decreasing, or remaining stable over time.
Visualization is used throughout the Machine Learning lifecycle. Before training a model, developers explore the dataset to understand distributions, relationships between variables, missing values, and feature importance. After training, visualizations help evaluate model performance and communicate results.
| Machine Learning Stage | Visualization Purpose |
|---|---|
| Data Collection | Understand available data. |
| Data Cleaning | Identify missing values and outliers. |
| Exploratory Data Analysis (EDA) | Find patterns and relationships. |
| Feature Engineering | Select important variables. |
| Model Evaluation | Visualize accuracy and errors. |
| Reporting | Present findings using charts. |
| Library | Purpose |
|---|---|
| Matplotlib | Basic and advanced charts. |
| Seaborn | Statistical graphics. |
| Plotly | Interactive dashboards. |
| Bokeh | Interactive web visualizations. |
| Altair | Declarative statistical graphics. |
Matplotlib is the oldest and most widely used visualization library in Python. It provides complete control over chart appearance and supports hundreds of chart types. Almost every other visualization library in Python is built on top of Matplotlib.
Seaborn is a high-level statistical visualization library built on top of Matplotlib. It provides attractive default styles and simplified functions for creating statistical charts directly from Pandas DataFrames.
| Feature | Matplotlib | Seaborn |
|---|---|---|
| Ease of Use | Moderate | Easy |
| Customization | Very High | High |
| Statistical Charts | Limited | Excellent |
| Pandas Integration | Good | Excellent |
| Built on | Base Library | Matplotlib |
| Chart | Purpose |
|---|---|
| Line Chart | Show trends over time. |
| Bar Chart | Compare categories. |
| Histogram | Display data distribution. |
| Scatter Plot | Study relationships between variables. |
| Box Plot | Detect outliers and spread. |
| Pie Chart | Show proportions. |
| Heatmap | Visualize correlations. |
| Pair Plot | Compare multiple variables. |
In the next lesson, you will learn Matplotlib from Beginner to Advanced, including line charts, bar charts, pie charts, histograms, scatter plots, subplots, legends, annotations, figure customization, and real-world data visualization projects.
Matplotlib is the most widely used data visualization library in Python. It provides a comprehensive set of tools for creating high-quality charts, graphs, and visualizations. Whether you are analyzing sales data, monitoring stock prices, exploring customer behavior, or building Machine Learning models, Matplotlib helps transform raw data into meaningful visual insights.
One of the biggest advantages of Matplotlib is its flexibility. Beginners can create simple charts with only a few lines of code, while experienced developers can build highly customized visualizations for research papers, dashboards, and business reports.
In this lesson, you will learn how to create the most commonly used charts in Data Science and Machine Learning, including line charts, bar charts, pie charts, histograms, scatter plots, subplots, and customized visualizations.
If Matplotlib is not already installed, install it using pip.
pip install matplotlib
In Jupyter Notebook or Google Colab:
!pip install matplotlib
import matplotlib.pyplot as plt
The pyplot module provides most of the plotting functions used in Python.
import matplotlib.pyplot as plt
x = [1,2,3,4,5]
y = [10,15,8,20,18]
plt.plot(x, y)
plt.show()
The plt.show() function displays the chart.
plt.plot(x,y)
plt.title("Monthly Sales")
plt.show()
plt.plot(x,y)
plt.xlabel("Month")
plt.ylabel("Sales")
plt.show()
plt.plot(x,
y,
color="red",
linestyle="--",
linewidth=3)
plt.show()
plt.plot(x,
y,
marker="o")
plt.show()
Bar charts compare values across different categories.
students = ["A","B","C","D"]
marks = [85,91,78,95]
plt.bar(students, marks)
plt.show()
plt.barh(students, marks)
plt.show()
Pie charts display proportions or percentages.
subjects = ["Python",
"SQL",
"Power BI",
"Excel"]
hours = [30,20,25,25]
plt.pie(hours,
labels=subjects,
autopct="%1.1f%%")
plt.show()
Histograms show the distribution of numerical values.
marks = [45,56,78,82,91,
85,76,68,95,
88,73]
plt.hist(marks)
plt.show()
Scatter plots display relationships between two numerical variables.
hours = [2,4,5,6,8]
marks = [55,68,75,82,96]
plt.scatter(hours, marks)
plt.show()
months = [1,2,3,4]
sales = [20,30,40,35]
profit = [5,7,10,9]
plt.plot(months,
sales,
label="Sales")
plt.plot(months,
profit,
label="Profit")
plt.legend()
plt.show()
plt.plot(x,y)
plt.grid(True)
plt.show()
plt.figure(figsize=(8,5))
plt.plot(x,y)
plt.show()
Subplots allow multiple charts to appear within the same figure.
plt.subplot(1,2,1)
plt.plot(x,y)
plt.subplot(1,2,2)
plt.bar(students, marks)
plt.show()
Charts can be saved as image files.
plt.plot(x,y)
plt.savefig("sales_chart.png")
| Chart | Purpose |
|---|---|
| Line Chart | Show trends over time. |
| Bar Chart | Compare categories. |
| Pie Chart | Display percentages. |
| Histogram | Show data distribution. |
| Scatter Plot | Study relationships. |
Suppose a Data Scientist wants to analyze how study hours affect student marks before training a prediction model.
import matplotlib.pyplot as plt
study_hours = [1,2,3,4,5,6,7]
marks = [40,50,58,68,75,88,95]
plt.scatter(study_hours, marks)
plt.title("Study Hours vs Marks")
plt.xlabel("Study Hours")
plt.ylabel("Marks")
plt.grid(True)
plt.show()
The scatter plot clearly shows a positive relationship between study hours and marks, helping determine whether study time is an important feature for a Machine Learning model.
plt.show().In the next lesson, you will learn Seaborn for Statistical Data Visualization, including count plots, box plots, violin plots, heatmaps, pair plots, distribution plots, regression plots, and advanced visualizations for Exploratory Data Analysis (EDA).
Seaborn is a high-level Python library used for creating attractive, informative, and statistical visualizations. Built on top of Matplotlib, Seaborn simplifies the process of creating professional-quality charts with minimal code. It integrates seamlessly with Pandas DataFrames, making it one of the most popular visualization libraries in Data Science, Machine Learning, Artificial Intelligence, and Business Analytics.
While Matplotlib provides complete control over chart customization, Seaborn focuses on simplifying statistical graphics. With built-in themes, color palettes, and advanced plotting functions, Seaborn allows data scientists to explore datasets efficiently during Exploratory Data Analysis (EDA).
In Machine Learning projects, visualization is often the first step after loading a dataset. Before training a model, it is important to understand the data, identify missing values, detect outliers, discover relationships between variables, and analyze feature distributions. Seaborn provides specialized charts designed specifically for these tasks.
If Seaborn is not installed, install it using pip.
pip install seaborn
In Jupyter Notebook or Google Colab:
!pip install seaborn
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
Seaborn includes several built-in datasets that are useful for learning and practice.
tips = sns.load_dataset("tips")
print(tips.head())
print(tips.info())
print(tips.describe())
Seaborn provides several attractive themes for charts.
sns.set_theme(style="darkgrid")
Popular styles include:
Line plots display trends over time or continuous relationships between variables.
sns.lineplot(
data=tips,
x="size",
y="total_bill"
)
plt.show()
Bar plots compare average values across categories.
sns.barplot(
data=tips,
x="day",
y="total_bill"
)
plt.show()
Count plots show the number of observations in each category.
sns.countplot(
data=tips,
x="day"
)
plt.show()
Histograms visualize the distribution of numerical variables.
sns.histplot(
data=tips,
x="total_bill",
bins=20
)
plt.show()
sns.kdeplot(
data=tips,
x="total_bill",
fill=True
)
plt.show()
Scatter plots reveal relationships between two numerical variables.
sns.scatterplot(
data=tips,
x="total_bill",
y="tip"
)
plt.show()
The hue parameter separates data into categories.
sns.scatterplot(
data=tips,
x="total_bill",
y="tip",
hue="sex"
)
plt.show()
sns.set_palette("Set2")
Popular palettes include:
plt.figure(figsize=(8,5))
sns.barplot(
data=tips,
x="day",
y="tip"
)
plt.show()
plt.figure(figsize=(8,5))
sns.barplot(
data=tips,
x="day",
y="tip"
)
plt.title("Average Tip by Day")
plt.xlabel("Day")
plt.ylabel("Average Tip")
plt.show()
Suppose a restaurant wants to understand customer tipping behavior before developing a Machine Learning model to predict future tips.
sns.scatterplot(
data=tips,
x="total_bill",
y="tip",
hue="time"
)
plt.title("Bill Amount vs Tip")
plt.show()
The scatter plot helps determine whether customers who spend more also tend to leave larger tips.
In the next lesson, you will learn advanced Seaborn visualizations, including Box Plots, Violin Plots, Heatmaps, Pair Plots, Joint Plots, Regression Plots, Correlation Analysis, and Exploratory Data Analysis (EDA) using real-world datasets.
After understanding the basic plots in Seaborn, the next step is learning advanced statistical visualizations used by Data Scientists and Machine Learning Engineers during Exploratory Data Analysis (EDA). These visualizations help identify relationships between variables, detect outliers, understand feature distributions, analyze correlations, and discover hidden patterns before training Machine Learning models.
Advanced Seaborn charts are commonly used in real-world projects involving customer analytics, healthcare, finance, education, marketing, fraud detection, and predictive modeling.
Exploratory Data Analysis (EDA) is the process of examining a dataset before building a Machine Learning model. It helps answer questions such as:
A Box Plot displays the distribution of numerical data and helps identify outliers.
import seaborn as sns
import matplotlib.pyplot as plt
tips = sns.load_dataset("tips")
sns.boxplot(
data=tips,
x="day",
y="total_bill"
)
plt.show()
A Box Plot displays:
A Violin Plot combines a Box Plot with a Kernel Density Plot, providing more information about the distribution of data.
sns.violinplot(
data=tips,
x="day",
y="total_bill"
)
plt.show()
Strip plots display every observation in the dataset.
sns.stripplot(
data=tips,
x="day",
y="tip"
)
plt.show()
Swarm plots prevent overlapping points and show individual observations clearly.
sns.swarmplot(
data=tips,
x="day",
y="tip"
)
plt.show()
Pair Plot is one of the most useful visualizations in Machine Learning. It automatically creates scatter plots between every numerical feature and histograms on the diagonal.
sns.pairplot(tips)
plt.show()
Pair Plots help discover feature relationships before selecting variables for Machine Learning models.
Correlation measures the relationship between numerical variables.
correlation = tips.corr(numeric_only=True)
print(correlation)
Heatmaps visualize the correlation matrix using colors.
sns.heatmap(
correlation,
annot=True,
cmap="coolwarm"
)
plt.show()
Heatmaps help identify highly correlated variables that may influence Machine Learning models.
Regression plots display the relationship between two numerical variables along with a regression line.
sns.regplot(
data=tips,
x="total_bill",
y="tip"
)
plt.show()
Joint Plot combines a scatter plot with histograms for both variables.
sns.jointplot(
data=tips,
x="total_bill",
y="tip",
kind="scatter"
)
plt.show()
FacetGrid creates multiple charts for different categories.
g = sns.FacetGrid(
tips,
col="time"
)
g.map(
plt.scatter,
"total_bill",
"tip"
)
plt.show()
sns.histplot(
tips["total_bill"],
kde=True
)
plt.show()
sns.catplot(
data=tips,
x="day",
y="tip",
kind="box"
)
plt.show()
| Chart | Best Used For |
|---|---|
| Line Plot | Time series trends |
| Bar Plot | Category comparison |
| Histogram | Distribution |
| Scatter Plot | Relationship between variables |
| Box Plot | Outlier detection |
| Violin Plot | Distribution comparison |
| Pair Plot | Feature relationships |
| Heatmap | Correlation analysis |
| Regression Plot | Linear relationship |
Suppose a bank wants to predict whether customers will apply for a loan. Before training the model, the Data Scientist performs Exploratory Data Analysis using Seaborn.
These visualizations help improve feature selection and model performance.
Seaborn provides built-in statistical plots, attractive default styles, and seamless integration with Pandas DataFrames, making exploratory analysis faster and easier.
A Heatmap visualizes correlations between variables using color intensity, helping identify strong positive or negative relationships.
Use a Box Plot to understand data distribution and identify outliers before training Machine Learning models.
In the next module, you will begin Data Preprocessing for Machine Learning, where you’ll learn how to clean datasets, handle missing values, encode categorical variables, scale numerical features, detect outliers, and prepare data for building high-performance Machine Learning models.