# Visualising data using Matplotlib and Seaborn

Visualizing data is an important part of data analysis, as it allows us to explore patterns and relationships in our data. One of the most popular libraries for data visualization in Python is Matplotlib. In this blog, we’ll take a look at how to use Matplotlib, as well as another popular data visualisation library, Seaborn, to create visualisations of different types of data.

Matplotlib is a Python library used for creating static, interactive, and animated visualizations in Python. It is a powerful library that can be used to create a wide range of visualizations, from simple line charts to complex 3D visualizations.

Seaborn is another Python library built on top of Matplotlib. It provides a high-level interface for creating attractive and informative statistical graphics. Seaborn is particularly useful for exploring and visualizing relationships between multiple variables in a dataset.

To get started with Matplotlib and Seaborn, we first need to install them. This can be done using pip, the Python package manager. Open a command prompt or terminal window and type the following commands:

``````pip install matplotlib
pip install seaborn``````

Once you have installed the libraries, you can start using them in your Python scripts.

##### Line Chart

A line chart is a basic type of chart that shows the relationship between two variables over time. Let’s create a simple line chart using Matplotlib.

``````import matplotlib.pyplot as plt

x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]

plt.plot(x, y)
plt.show()``````

This will create a simple line chart with the x-axis values on the bottom and the y-axis values on the left.

##### Bar Chart

A bar chart is a chart that uses bars to represent data. Bar charts are useful for comparing data across different categories. Let’s create a simple bar chart using Matplotlib.

```import matplotlib.pyplot as plt
x = ['A', 'B', 'C', 'D', 'E']
y = [20, 15, 25, 30, 10]
plt.bar(x, y)
plt.show()```

This will create a simple bar chart with the x-axis labels on the bottom and the y-axis values on the left.

##### Scatter Plot

A scatter plot is a chart that uses dots to represent data. Scatter plots are useful for exploring relationships between two variables. Let’s create a simple scatter plot using Matplotlib.

```import matplotlib.pyplot as plt

x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]

plt.scatter(x, y)
plt.show()```

This will create a simple scatter plot with the x-axis values on the bottom and the y-axis values on the left.

##### Histogram

A histogram is a chart that displays the distribution of a dataset. Histograms are useful for identifying patterns in data. Let’s create a simple histogram using Matplotlib.

```import matplotlib.pyplot as plt
import numpy as np

data = np.random.normal(size=1000)

plt.hist(data, bins=30)
plt.show()```

This will create a simple histogram with the x-axis values on the bottom and the y-axis values on the left.

##### Heatmap

A heatmap is a chart that uses color to represent data. Heatmaps are useful for visualizing patterns in large datasets. Let’s create a simple heatmap using Seaborn.

```import seaborn as sns
import numpy as np

data = np.random.rand(10, 10)

sns.heatmap(data, cmap='YlGnBu')
plt.show```

##### Boxplot

A boxplot is a chart that shows the distribution of a dataset using quartiles. Boxplots are useful for identifying outliers and comparing multiple distributions. Let’s create a simple boxplot using Seaborn.

```import seaborn as sns
import numpy as np

data = np.random.normal(size=(10, 3))

sns.boxplot(data=data)
plt.show()```

This will create a simple boxplot with three boxes representing the distribution of each column of data.

##### Pairplot

A pairplot is a chart that shows pairwise relationships in a dataset. Pairplots are useful for exploring the relationships between multiple variables in a dataset. Let’s create a simple pairplot using Seaborn.

```import seaborn as sns
import pandas as pd

sns.pairplot(data=iris)
plt.show()```

This will create a pairplot that shows the pairwise relationships between the four features of the iris dataset.

##### Barplot

A barplot is a chart that shows the average value of a dataset for different categories. Barplots are useful for comparing average values across different categories. Let’s create a simple barplot using Seaborn.

```import seaborn as sns
import pandas as pd

sns.barplot(x='day', y='total_bill', data=tips)
plt.show()```

This will create a barplot that shows the average total bill for each day of the week in the tips dataset.

##### Violinplot

A violinplot is a chart that shows the distribution of a dataset using a kernel density estimate. Violinplots are useful for comparing multiple distributions. Let’s create a simple violinplot using Seaborn.

```import seaborn as sns
import numpy as np

data = np.random.normal(size=(10, 3))

sns.violinplot(data=data)
plt.show()```

This will create a simple violinplot with three violins representing the distribution of each column of data.

##### FacetGrid

A FacetGrid is a chart that shows the relationships between multiple variables in a dataset using multiple subplots. FacetGrids are useful for exploring the relationships between multiple variables in a dataset. Let’s create a simple FacetGrid using Seaborn.

```import seaborn as sns
import pandas as pd

g = sns.FacetGrid(tips, col='time', row='day')
g.map(sns.scatterplot, 'total_bill', 'tip')
plt.show()```

This will create a FacetGrid that shows the relationship between total bill and tip for each day of the week and each time of day in the tips dataset.

##### Animated Visualization using Matplotlib

Matplotlib provides an animation module called `matplotlib.animation`, which allows users to create animated plots. Here is an example of how to create a simple animated plot using `matplotlib.animation`:

```import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation

# Create a figure and axes
fig, ax = plt.subplots()

# Define a function to plot a sine wave
def plot_sine_wave(i):
x = np.linspace(0, 2 * np.pi, 1000)
y = np.sin(x - i * np.pi / 10)
ax.clear()
ax.plot(x, y)

# Create and save animation
ani = FuncAnimation(fig, plot_sine_wave, frames=200, interval=20)
ani.save('plot_sine_wave.mp4',
writer = 'ffmpeg', fps = 30)```

This code will create an animated plot that shows a sine wave that oscillates over time.

##### Interactive Visualisation using Matplotlib

Matplotlib provides an interactive module called `matplotlib.widgets`, which allows users to create interactive widgets in Matplotlib plots. Here is an example of how to create a simple interactive plot using `matplotlib.widgets`:

```import numpy as np
import matplotlib.pyplot as plt
from matplotlib.widgets import Slider

# Create a figure and axes
fig, ax = plt.subplots()

# Define a function to plot a sine wave
def plot_sine_wave(freq, amp):
x = np.linspace(0, 2 * np.pi, 1000)
y = amp * np.sin(freq * x)
ax.plot(x, y)

axfreq = plt.axes([0.25, 0.15, 0.65, 0.03])
axamplitude = plt.axes([0.25, 0.1, 0.65, 0.03])

# Create sliders for frequency and amplitude
freq_slider = Slider(ax=axfreq, label='Frequency', valmin=0, valmax=20, valinit=1, orientation='horizontal', valstep=1)
amp_slider = Slider(ax=axamplitude, label='Amplitude', valmin=0, valmax=10, valinit=0.5, orientation='horizontal',
valstep=0.1)

# Define a function to update the plot when sliders are changed
def update(val):
freq = freq_slider.val
amp = amp_slider.val
ax.clear()
plot_sine_wave(freq, amp)
fig.canvas.draw_idle()

# Connect the sliders to the update function
freq_slider.on_changed(update)
amp_slider.on_changed(update)

# Plot a sine wave with initial values of frequency and amplitude
plot_sine_wave(1, 0.5)

# Show the plot
plt.show()```

This code will create an interactive plot that allows users to change the frequency and amplitude of a sine wave using sliders.

Scroll to Top