Following our general introduction to the matplotlib environment, let’s explore the types of graphs this Python library can produce.

Among the most commonly used graphs for data presentation are:

• Histograms
• Box plots
• Scatter plots
• Bar charts
• Line graphs

Histograms

Histograms primarily illustrate the distribution of a continuous variable. The data is divided into uniform intervals (bins), and the frequency of each bin is represented.

You can create histograms using the following function:

plt.hist()

This function accepts several arguments:

• bins: number of intervals for dividing the data
• color and edgecolor: fill color of the bars and color of their edges
• alpha: controls the transparency of the bars

The following program generates a series of data with normal distribution and displays them using histograms:

import matplotlib.pyplot as plt
import numpy as np

# Create a random dataset with normal distribution
data = np.random.randn(1000)

# Create a histogram
plt.figure(figsize=(10, 6))
plt.hist(data, bins=30, color='skyblue', edgecolor='black', alpha=0.7)

# Add title and labels
plt.title('Data Distribution', fontsize=16, fontweight='bold')
plt.xlabel('Values')
plt.ylabel('Frequency')
plt.grid(axis='y', linestyle='--', alpha=0.6)

plt.show()

import matplotlib.pyplot as plt
import numpy as np

# Create a random dataset with normal distribution
data = np.random.randn(1000)

# Create a histogram
plt.figure(figsize=(10, 6))
plt.hist(data, bins=30, color='skyblue', edgecolor='black', alpha=0.7)

# Add title and labels
plt.title('Data Distribution', fontsize=16, fontweight='bold')
plt.xlabel('Values')
plt.ylabel('Frequency')
plt.grid(axis='y', linestyle='--', alpha=0.6)

plt.show()

The resulting graph looks as follows:

To increase the detail of the distribution, we can increase the number of bins. In the following example, we’ve increased the number of bins from 30 to 300:

Box Plots

Box plots (also known as box-and-whisker plots) are ideal for highlighting the distribution of continuous variables in quartiles. The box shows the data ranging from the first to the third quartile, with the median highlighted. Outliers are also displayed.

Box plots are created with the function:

plt.boxplot()

The key parameters are:

• data: the variable containing the values
• patch_artist: boolean, indicates whether the box plot should be filled with colors
• notch: boolean, indicates the confidence interval of the median
• vert: boolean, specifies whether the graph should be oriented vertically

Let’s create a box plot using normally distributed data. We’ll generate a list (data) containing three groups of 100 random numbers. Each group will have a mean of 0 and standard deviations of 1, 2, and 3 respectively.

np.random.seed(10)  # Set a seed for reproducibility
data = [np.random.normal(0, std, 100) for std in range(1, 4)]

# Create the boxplot
plt.figure(figsize=(10, 6))
plt.boxplot(data, patch_artist=True, notch=True, vert=True)

# Add title and labels
plt.title('Data Distribution with Boxplot', fontsize=16, fontweight='bold')
plt.xlabel('Dataset')
plt.ylabel('Values')
plt.xticks([1, 2, 3], ['Dataset 1', 'Dataset 2', 'Dataset 3'])
plt.grid(axis='y', linestyle='--', alpha=0.6)

plt.show()

np.random.seed(10)  # Set a seed for reproducibility
data = [np.random.normal(0, std, 100) for std in range(1, 4)]

# Create the boxplot
plt.figure(figsize=(10, 6))
plt.boxplot(data, patch_artist=True, notch=True, vert=True)

# Add title and labels
plt.title('Data Distribution with Boxplot', fontsize=16, fontweight='bold')
plt.xlabel('Dataset')
plt.ylabel('Values')
plt.xticks([1, 2, 3], ['Dataset 1', 'Dataset 2', 'Dataset 3'])
plt.grid(axis='y', linestyle='--', alpha=0.6)

plt.show()

The resulting graph will look like this:

Scatter Plots

Scatter plots are used to highlight relationships between two variables, revealing trends and correlations. They’re particularly useful for visualizing how one variable changes to another.

To generate a scatter plot, use the following function:

plt.scatter()

The key parameters for this function are:

• x and y: the variables containing the values to be compared
• color and edgecolor: colors of the points and their borders
• alpha: transparency level, which can help highlight overlapping points

Here’s an example of how to create a scatter plot comparing two variables:

np.random.seed(0)
x = np.random.rand(100)
y = 2 * x + np.random.normal(0, 0.1, 100)

plt.figure(figsize=(10, 6))
plt.scatter(x, y, color='teal', alpha=0.7, edgecolor='k')

# Add title and labels
plt.title('Scatter Plot', fontsize=16, fontweight='bold')
plt.xlabel('X Variable')
plt.ylabel('Y Variable')
plt.grid(True, linestyle='--', alpha=0.6)

plt.show()

np.random.seed(0)
x = np.random.rand(100)
y = 2 * x + np.random.normal(0, 0.1, 100)

plt.figure(figsize=(10, 6))
plt.scatter(x, y, color='teal', alpha=0.7, edgecolor='k')

# Add title and labels
plt.title('Scatter Plot', fontsize=16, fontweight='bold')
plt.xlabel('X Variable')
plt.ylabel('Y Variable')
plt.grid(True, linestyle='--', alpha=0.6)

plt.show()

Bar Charts

Bar charts effectively display the count or frequency of categorical data. They provide a clear visual representation of data categories and their corresponding values.

To generate a bar chart, use the following function:

plt.bar()

This function accepts several key parameters:

• categories, values: pairs of categories and their corresponding counts or frequencies
• color: fill color of the bars
• edgecolor: color of the bar borders

Here’s an example of code generating a bar chart:

categories = ['A', 'B', 'C', 'D']
values = [15, 30, 45, 10]

plt.figure(figsize=(10, 6))
plt.bar(categories, values, color='cadetblue', edgecolor='black')

# Add title and labels
plt.title('Category Count', fontsize=16, fontweight='bold')
plt.xlabel('Categories')
plt.ylabel('Count')
plt.grid(axis='y', linestyle='--', alpha=0.6)

plt.show()

categories = ['A', 'B', 'C', 'D']
values = [15, 30, 45, 10]

plt.figure(figsize=(10, 6))
plt.bar(categories, values, color='cadetblue', edgecolor='black')

# Add title and labels
plt.title('Category Count', fontsize=16, fontweight='bold')
plt.xlabel('Categories')
plt.ylabel('Count')
plt.grid(axis='y', linestyle='--', alpha=0.6)

plt.show()

The resulting graph looks like this:

Line Graph

Line graphs are ideal for showing time series.

By indicating time intervals on the x-axis, we can see how values change over time.

The command that allows us to create line graphs is:

plt.plot()

which accepts as parameters:

• date, values: pair of date and values on that date
• colors and other parameters to adjust the graphical appearance

Here’s an example of a line graph:

dates = np.arange('2024-01', '2024-06', dtype='datetime64[D]')
values = np.random.randn(len(dates)).cumsum()

plt.figure(figsize=(12, 6))
plt.plot(dates, values, color='dodgerblue', linewidth=2)

# Add title and labels
plt.title('Time Series', fontsize=16, fontweight='bold')
plt.xlabel('Date')
plt.ylabel('Cumulative Value')
plt.xticks(rotation=45)
plt.grid(True, linestyle='--', alpha=0.6)

plt.show()

dates = np.arange('2024-01', '2024-06', dtype='datetime64[D]')
values = np.random.randn(len(dates)).cumsum()

plt.figure(figsize=(12, 6))
plt.plot(dates, values, color='dodgerblue', linewidth=2)

# Add title and labels
plt.title('Time Series', fontsize=16, fontweight='bold')
plt.xlabel('Date')
plt.ylabel('Cumulative Value')
plt.xticks(rotation=45)
plt.grid(True, linestyle='--', alpha=0.6)

plt.show()

The already impressive capabilities of matplotlib can be significantly enhanced by incorporating the Seaborn library. Built upon matplotlib’s foundation, Seaborn offers a user-friendly approach to creating intricate and visually appealing graphs. This powerful combination allows data scientists and analysts to effortlessly generate complex visualizations, expanding the range of possibilities for data representation and analysis.

Python offers several libraries for creating professional graphs, but Matplotlib stands out as the foundation upon which many others are built. Often referred to by its alias “plt,” Matplotlib enables users to generate complex, element-rich graphs as well as multiple visualizations. Another popular library, Seaborn (alias “sns”), functions as an extension of Matplotlib and requires its installation to operate. Seaborn enhances both procedural management and graphical handling compared to Matplotlib. In this article, we’ll explore Matplotlib, beginning with its fundamental concepts and progressing to the development of more sophisticated statistical graphs.

Installation and Importing Matplotlib

To install Matplotlib, enter the following command in your terminal:

pip install matplotlib

pip install matplotlib

It’s best to perform this installation within a virtual environment.

After installation, import the library into your Python program with:

import matplotlib.pyplot as plt

import matplotlib.pyplot as plt

Conventionally, Matplotlib is aliased as “plt”. Note that we typically import the pyplot module directly. This module offers functionality similar to MATLAB—a widely used program in scientific and technical fields—and provides access to advanced graphing functions.

Figure, Axes, and Plot

To fully comprehend Matplotlib, it’s crucial to understand the relationship between figure, axes, and plot.

The figure is the entire window or area of the graph we’re creating—the foundation for any Matplotlib visualization. Without it, we’d have nowhere to place our graphs. Think of it as an artist’s blank canvas: it’s the space where all our graphical elements come to life. A single figure can house one or more graphs, enabling complex, multi-dimensional visualizations. Far from being a passive container, the figure actively shapes how we organize and present our data.

Axes represent individual drawing areas within a figure, each containing a specific graph. This structure offers great flexibility. In its simplest form, we might have a single axes within a figure. But the real power emerges when creating complex visualizations—a single figure can host multiple axes, allowing us to present two, three, or more graphs simultaneously. This feature is particularly useful for comparing different datasets or showing various perspectives of the same information, providing a comprehensive view of our data.

Plot is the key function that brings our data to life on an axes. It’s the heart of Matplotlib’s graphic creation, transforming abstract numbers into visual representations. With plot, we define not only the basic shape of our graph—whether lines, points, or bars—but also customize every aspect of the visualization. This includes colors, line styles, point sizes, and even element transparency.

Figure

Moving on to practical aspects, the creation of a figure is done by specifying its dimensions as a parameter:

fig = plt.figure(figsize=(10,6))

fig = plt.figure(figsize=(10,6))

fig is the figure we have created using the plt.figure module; figsize is the parameter that allows us to specify its dimensions. In this specific case, we have created a figure, called fig, with dimensions of 10 x 6 inches.

Other parameters that can be applied to figure are:

• dpi: resolution of the figure in dots per inch
• facecolor: background color
• edgecolor: border color
• tight_layout: optimizes the layout of contents
• savefig: saves the entire figure in various formats (e.g., savefig(“figure.png”, dpi=300, transparent=True saves the figure with the specified name and format, with a resolution of 300 dpi and with a transparent background)

Axes

To add an axes to our figure, we use the add_subplot method:

ax = fig.add_subplot(1,1,1)

ax = fig.add_subplot(1,1,1)

ax is the axes we have created on the figure fig. The axis is positioned on the first row, first column, and is the first graph of the figure (1,1,1) which, in the case of single graphs, is also the only axes present.

If we want to use only one axes, we don’t even need to create it. It is generated automatically. We just need to create a figure and start plotting.

Every time we create a figure, it becomes the active figure and all subsequent graphical commands will refer to it. If we want to create multiple figures and switch between them when adding graphical elements, we can identify the figure with a number (figure(1), for example) and recall it whenever we want to work on it:

# Create a figure with a graph
plt.figure(1)
plt.plot([1, 2, 3, 4])
plt.title("Graph 1")

# Create a new figure with another graph
plt.figure(2)
plt.plot([4, 3, 2, 1])
plt.title("Graph 2")

# Return to the first figure and add something
plt.figure(1)
plt.xlabel("X-axis")

# Create a figure with a graph
plt.figure(1)
plt.plot([1, 2, 3, 4])
plt.title("Graph 1")

# Create a new figure with another graph
plt.figure(2)
plt.plot([4, 3, 2, 1])
plt.title("Graph 2")

# Return to the first figure and add something
plt.figure(1)
plt.xlabel("X-axis")

The subplots function allows us to create figures and axes with a single command. This versatile method works for both single and multiple graph layouts:

fig, ax = plt.subplots()

fig, ax = plt.subplots()

The subplots function takes three key parameters:

• nrows: number of rows (default is 1)
• ncols: number of columns (default is 1)
• figsize: dimensions of the figure in inches

# Create a single 10 x 6 inch graph
fig, ax = plt.subplots(1, 1, figsize=(10, 6))

# Create 4 graphs in a 2x2 layout on a 10 x 6 inch figure
fig, ax = plt.subplots(2, 2, figsize=(10, 6))

# Create a single 10 x 6 inch graph
fig, ax = plt.subplots(1, 1, figsize=(10, 6))

# Create 4 graphs in a 2x2 layout on a 10 x 6 inch figure
fig, ax = plt.subplots(2, 2, figsize=(10, 6))

Compared to the older subplot method, which only allows creating one axes at a time, subplots offers greater flexibility. It’s now the preferred choice in modern Matplotlib programming.

After creating a figure and one or more axes, we can begin drawing our graphs within these axes. Each axes is identified as a two-dimensional array, indicating its row and column position:

# Create a figure with 4 axes arranged in two rows and two columns
fig, ax = plt.subplots(2, 2, figsize=(10, 6))

# Draw on the first axes (top-left)
ax[0, 0].plot(...)

# Draw on the second axes (top-right)
ax[0, 1].plot(...)

# Draw on the third axes (bottom-left)
ax[1, 0].plot(...)

# Draw on the fourth axes (bottom-right)
ax[1, 1].plot(...)

# Create a figure with 4 axes arranged in two rows and two columns
fig, ax = plt.subplots(2, 2, figsize=(10, 6))

# Draw on the first axes (top-left)
ax[0, 0].plot(...)

# Draw on the second axes (top-right)
ax[0, 1].plot(...)

# Draw on the third axes (bottom-left)
ax[1, 0].plot(...)

# Draw on the fourth axes (bottom-right)
ax[1, 1].plot(...)

Below are the layouts of the axes created with the following commands:

fig, axes = plt.subplots(1, 1, figsize=(x, x))

fig, axes = plt.subplots(2, 2, figsize=(x, x))

fig, axes = plt.subplots(2, 1, figsize=(x, x))

Several parameters can be applied to axes to customize their appearance. The most important ones are:

• set_xlim and set_ylim: Define the axis range. For example, set_xlim([0, 10]) sets the x-axis from 0 to 10.
• set_xlabel and set_ylabel: Set the axis labels.
• set_title: Set the graph title.
• set_xticks and set_yticks: Place reference marks on the axes. For example, set_xticks([1, 2, 3, 4, 5]) adds ticks at those values.
• grid: A boolean to show (True) or hide (False) the grid.
• set_facecolor: Set the background color.
• spines: Control the visibility and color of borders. For example, spine[“top”].set_visible(False) removes the top border, while spine[“right”].set_color(“blue”) colors the right border blue.
• tight_layout: Optimize the layout of multiple graphs.
• autoscale: Adjust the axes to fit the data.
• axis: Control axis visibility. axis(“off”) hides all axes, while axis(“equal”) makes axis limits equal on all axes.

Once we’ve set up the number, arrangement, and appearance of the axes (and thus the graphs) on the figure, we can proceed to draw the graphs using the plot method.

Plot

The plot function offers numerous parameters for extensive graph customization:

• x, y: Coordinates of points to plot. These are typically arrays or lists of coordinate values, not just single points.
• color: Line color. Specify using color names (“red”, “blue”), abbreviations (“r” for red, “b” for blue), or hexadecimal codes (“#FF5733”).
• linestyle (ls): Line style. Options include “-” (solid), “–” (dashed), “-.” (dash-dot), and “:” (dotted).
• linewidth (lw): Line thickness (numerical value).
• marker: Point style. Examples: “o” (circle), “s” (square), “x” (cross), “d” (diamond).
• markersize (ms): Size of markers.
• markerfacecolor (mfc): Internal color of markers.
• markeredgecolor (mec): Color of marker borders.
• label: Legend label.
• alpha: Line transparency (0 for fully transparent, 1 for fully opaque).

Now, let’s combine these elements to create a figure with four graphs in a 2×2 layout:

import matplotlib.pyplot as plt
import numpy as np

# Create a figure and a 2x2 grid of subplots
fig, axes = plt.subplots(2, 2, figsize=(10, 8), dpi=100)

# Generate some data to plot
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)
y3 = np.tan(x)
y4 = np.exp(-x)

# Plot on the first axes (axes[0, 0])
axes[0, 0].plot(x, y1, color='b', linestyle='--', linewidth=2, marker='o', markersize=5)
axes[0, 0].set_title('Sine Wave')
axes[0, 0].set_xlabel('Time (s)')
axes[0, 0].set_ylabel('Amplitude')
axes[0, 0].grid(True)
axes[0, 0].set_xlim([0, 10])
axes[0, 0].set_ylim([-1.5, 1.5])

# Plot on the second axes (axes[0, 1])
axes[0, 1].plot(x, y2, color='r', linestyle='-', linewidth=1.5, marker='s', markersize=4)
axes[0, 1].set_title('Cosine Wave')
axes[0, 1].set_xlabel('Time (s)')
axes[0, 1].set_ylabel('Amplitude')
axes[0, 1].grid(True, which='both', axis='both')
axes[0, 1].set_xlim([0, 10])
axes[0, 1].set_ylim([-1.5, 1.5])

# Plot on the third axes (axes[1, 0])
axes[1, 0].plot(x, y3, color='g', linestyle='-.', linewidth=1, marker='d', markersize=6)
axes[1, 0].set_title('Tangent (limited range)')
axes[1, 0].set_xlabel('Time (s)')
axes[1, 0].set_ylabel('Value')
axes[1, 0].set_xlim([0, 10])
axes[1, 0].set_ylim([-10, 10])
axes[1, 0].grid(True)

# Plot on the fourth axes (axes[1, 1])
axes[1, 1].plot(x, y4, color='purple', linestyle=':', linewidth=3, marker='x', markersize=8)
axes[1, 1].set_title('Exponential Decay')
axes[1, 1].set_xlabel('Time (s)')
axes[1, 1].set_ylabel('Amplitude')
axes[1, 1].set_xlim([0, 10])
axes[1, 1].set_ylim([0, 1])

# Adjust the layout to prevent overlap of labels and titles
fig.tight_layout()

# Save the figure as an image
fig.savefig('subplot_figure_subplots.png', dpi=300)

# Show the figure
plt.show()

import matplotlib.pyplot as plt
import numpy as np

# Create a figure and a 2x2 grid of subplots
fig, axes = plt.subplots(2, 2, figsize=(10, 8), dpi=100)

# Generate some data to plot
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)
y3 = np.tan(x)
y4 = np.exp(-x)

# Plot on the first axes (axes[0, 0])
axes[0, 0].plot(x, y1, color='b', linestyle='--', linewidth=2, marker='o', markersize=5)
axes[0, 0].set_title('Sine Wave')
axes[0, 0].set_xlabel('Time (s)')
axes[0, 0].set_ylabel('Amplitude')
axes[0, 0].grid(True)
axes[0, 0].set_xlim([0, 10])
axes[0, 0].set_ylim([-1.5, 1.5])

# Plot on the second axes (axes[0, 1])
axes[0, 1].plot(x, y2, color='r', linestyle='-', linewidth=1.5, marker='s', markersize=4)
axes[0, 1].set_title('Cosine Wave')
axes[0, 1].set_xlabel('Time (s)')
axes[0, 1].set_ylabel('Amplitude')
axes[0, 1].grid(True, which='both', axis='both')
axes[0, 1].set_xlim([0, 10])
axes[0, 1].set_ylim([-1.5, 1.5])

# Plot on the third axes (axes[1, 0])
axes[1, 0].plot(x, y3, color='g', linestyle='-.', linewidth=1, marker='d', markersize=6)
axes[1, 0].set_title('Tangent (limited range)')
axes[1, 0].set_xlabel('Time (s)')
axes[1, 0].set_ylabel('Value')
axes[1, 0].set_xlim([0, 10])
axes[1, 0].set_ylim([-10, 10])
axes[1, 0].grid(True)

# Plot on the fourth axes (axes[1, 1])
axes[1, 1].plot(x, y4, color='purple', linestyle=':', linewidth=3, marker='x', markersize=8)
axes[1, 1].set_title('Exponential Decay')
axes[1, 1].set_xlabel('Time (s)')
axes[1, 1].set_ylabel('Amplitude')
axes[1, 1].set_xlim([0, 10])
axes[1, 1].set_ylim([0, 1])

# Adjust the layout to prevent overlap of labels and titles
fig.tight_layout()

# Save the figure as an image
fig.savefig('subplot_figure_subplots.png', dpi=300)

# Show the figure
plt.show()

The resulting figure will look like this: