# 5 Best Ways to Make Two Plots Side by Side Using Python

Rate this post

π‘ Problem Formulation: In data analysis and visualization, it is often necessary to compare different datasets or the same data under different conditions. Python, a leading programming language in such tasks, allows the creation of plots. The specific problem this article addresses is how to present two plots side by side for effective comparison. Imagine having two arrays of data representing experiment results under varying conditions; the desired output is to display two corresponding plots next to each other on the same canvas.

## Method 1: Using Matplotlib’s subplot

The `matplotlib` library in Python has a function called `subplot` which is used to organize plots in a grid. When you want to make two plots side by side, you can create a grid with one row and two columns and then draw each plot in its respective column.

Here’s an example:

```import matplotlib.pyplot as plt

x = [1, 2, 3, 4]
y1 = [10, 20, 25, 30]
y2 = [40, 35, 30, 20]

plt.subplot(1, 2, 1)
plt.plot(x, y1)

plt.subplot(1, 2, 2)
plt.plot(x, y2)

plt.show()```

The output is two side-by-side line plots on a single figure window.

This code snippet first imports the Matplotlib plotting library. Then, two datasets are defined. The `subplot` function is called twice to configure the first and second plot positions. Each `plot` function draws the respective lines, and `plt.show()` displays them side by side.

## Method 2: Using Matplotlib’s subplots

A more modern way to create side-by-side plots with matplotlib is using the `subplots` function. This function makes it easy to create a figure and a set of subplots at once, providing better control and less code.

Here’s an example:

```import matplotlib.pyplot as plt

x = [1, 2, 3, 4]
y1 = [10, 20, 30, 40]
y2 = [40, 30, 20, 10]

fig, (ax1, ax2) = plt.subplots(1, 2)
ax1.plot(x, y1)
ax2.plot(x, y2)

plt.show()```

The output displays two line plots side by side in one figure.

In this example, the `subplots` function is used to create a one row by two columns figure and returns a separate axes object for each subplot. The plots are then drawn individually on the `ax1` and `ax2` axes objects followed by displaying them using `plt.show()`.

## Method 3: Using Seaborn’s FacetGrid

The Seaborn library, which builds on Matplotlib, provides higher-level interfaces for drawing attractive and informative statistical graphics. One way to plot multiple plots side by side is using the `FacetGrid`. This function is particularly useful when you’re dealing with data frames and wish to apply a function to create plots for each subset of the data.

Here’s an example:

```import seaborn as sns
import matplotlib.pyplot as plt

# Assume 'df' is a DataFrame with 'category', 'x', and 'y' columns
g = sns.FacetGrid(df, col="category")
g.map(plt.plot, "x", "y")

plt.show()```

The output is multiple line plots side by side, one for each category.

This snippet first imports Seaborn and Matplotlib. Assuming there is a pandas DataFrame `df` with a ‘category’ column, `FacetGrid` uses this to create a grid of plots. The `map` function then plots the ‘x’ and ‘y’ columns in each subplot accordingly.

## Method 4: Using Pyplot’s tight_layout

Tight layout automatically adjusts subplot parameters to give specified padding that you often need after creating multiple subplots. This method is particularly good when your subplots have titles or labels that would otherwise overlap.

Here’s an example:

```import matplotlib.pyplot as plt

x = [1, 2, 3, 4]
y1 = [10, 20, 25, 30]
y2 = [40, 35, 30, 20]

plt.subplot(121)
plt.plot(x, y1)
plt.title('First Plot')

plt.subplot(122)
plt.plot(x, y2)
plt.title('Second Plot')

plt.tight_layout()
plt.show()```

The output is two neatly arranged side-by-side plots with titles.

The code uses the subplot numbers (121 and 122) to denote one row, two columns, and the first and second subplot respectively. After plotting, `plt.tight_layout()` ensures that the plots are spaced properly so that the titles and labels don’t overlap. The plots are then displayed with `plt.show()`.

## Bonus One-Liner Method 5: Using Pyplot’s Figure with Axes

Python allows for concise, one-liner creations of side-by-side plots by creating a figure and adding axes explicitly. This method gives fine-grained control of the position of the plots.

Here’s an example:

```import matplotlib.pyplot as plt

x = [1, 2, 3, 4]
y1 = [10, 20, 30, 40]
y2 = [40, 30, 20, 10]

fig = plt.figure()
ax1 = fig.add_axes([0.1, 0.1, 0.4, 0.8])
ax2 = fig.add_axes([0.55, 0.1, 0.4, 0.8])
ax1.plot(x, y1)
ax2.plot(x, y2)

plt.show()```

This produces two custom-spaced line plots in a single figure.

This one-liner approach utilizes matplotlib’s `figure` object to set up the plotting areas explicitly. The rectangles defined in `add_axes` specify the left, bottom, width, and height of the plot area in the figure’s coordinate space. Each plot is then drawn on the respective axes and displayed.

## Summary/Discussion

• Method 1: Using Matplotlib’s subplot. Easy to use. Limited customization of individual plots.
• Method 2: Using Matplotlib’s subplots. Modern and versatile. Slightly more complex for beginners.
• Method 3: Using Seaborn’s FacetGrid. High level of abstraction. Requires familiarity with pandas.
• Method 4: Using Pyplot’s tight_layout. Handles overlapping titles and labels well. Can require manual adjustments for complex layouts.
• Bonus Method 5: Using Pyplot’s Figure with Axes. High level of control over plot position. Can be too low-level for simple tasks.