Mastering Matplotlib Subplots and ylim: A Comprehensive Guide

Mastering Matplotlib Subplots and ylim: A Comprehensive Guide

Matplotlib subplots ylim are essential components in creating complex and informative visualizations using the popular Python plotting library, Matplotlib. This comprehensive guide will delve deep into the intricacies of working with subplots and setting y-axis limits in Matplotlib, providing you with the knowledge and skills to create stunning and informative plots.

Understanding Matplotlib Subplots and ylim

Before we dive into the details, let’s briefly explain what Matplotlib subplots and ylim are:

1. Matplotlib subplots: Subplots allow you to create multiple plots within a single figure. This is particularly useful when you want to compare different datasets or show various aspects of the same data side by side.

2. ylim: The ylim function in Matplotlib is used to set the limits of the y-axis in a plot. This allows you to control the range of values displayed on the y-axis, which can be crucial for properly visualizing your data.

Now, let’s explore these concepts in depth, starting with Matplotlib subplots.

Creating Basic Matplotlib Subplots

To create subplots in Matplotlib, we use the plt.subplots() function. This function returns a figure object and an array of axes objects, which we can use to plot our data.

Let’s start with a simple example of creating a 2×2 grid of subplots:

import matplotlib.pyplot as plt
import numpy as np

# Create a 2x2 grid of subplots
fig, axs = plt.subplots(2, 2, figsize=(10, 8))

# Generate some sample data
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)
y3 = np.exp(-x/10)
y4 = x**2

# Plot data on each subplot
axs[0, 0].plot(x, y1)
axs[0, 0].set_title('Sine Wave')
axs[0, 1].plot(x, y2)
axs[0, 1].set_title('Cosine Wave')
axs[1, 0].plot(x, y3)
axs[1, 0].set_title('Exponential Decay')
axs[1, 1].plot(x, y4)
axs[1, 1].set_title('Quadratic Function')

# Add a main title
fig.suptitle('Basic Matplotlib Subplots Example - how2matplotlib.com', fontsize=16)

# Adjust layout and display the plot
plt.tight_layout()
plt.show()

# Print output
print("The plot has been displayed.")

Output:

In this example, we create a 2×2 grid of subplots using plt.subplots(2, 2). We then generate some sample data and plot it on each subplot using the axs array. The axs array is a 2D array where axs[i, j] represents the subplot at the i-th row and j-th column.

Customizing Matplotlib Subplots

Now that we’ve created basic subplots, let’s explore how to customize them further. We’ll look at adjusting subplot sizes, spacing, and adding shared axes.

import matplotlib.pyplot as plt
import numpy as np

# Create a figure with custom subplot layout
fig = plt.figure(figsize=(12, 8))
gs = fig.add_gridspec(2, 3, width_ratios=[1, 2, 1], height_ratios=[1, 1.5])

# Generate sample data
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)
y3 = np.exp(-x/10)

# Create subplots with different sizes
ax1 = fig.add_subplot(gs[0, 0])
ax2 = fig.add_subplot(gs[0, 1:])
ax3 = fig.add_subplot(gs[1, :])

# Plot data on each subplot
ax1.plot(x, y1)
ax1.set_title('Sine Wave')
ax2.plot(x, y2)
ax2.set_title('Cosine Wave')
ax3.plot(x, y3)
ax3.set_title('Exponential Decay')

# Add a main title
fig.suptitle('Customized Matplotlib Subplots - how2matplotlib.com', fontsize=16)

# Adjust layout and display the plot
plt.tight_layout()
plt.show()

# Print output
print("The customized subplot layout has been displayed.")

Output:

In this example, we use fig.add_gridspec() to create a custom grid layout for our subplots. We specify different width and height ratios for the columns and rows, respectively. We then use fig.add_subplot() to add subplots to specific grid locations, allowing us to create subplots of different sizes.

Using Matplotlib ylim to Set Y-Axis Limits

Now that we’ve covered subplots, let’s focus on using ylim to control the y-axis limits of our plots. The ylim function allows us to set the minimum and maximum values displayed on the y-axis.

Here’s an example demonstrating how to use ylim:

import matplotlib.pyplot as plt
import numpy as np

# Generate sample data
x = np.linspace(0, 10, 100)
y = np.sin(x)

# Create a plot
fig, ax = plt.subplots(figsize=(8, 6))
ax.plot(x, y)

# Set y-axis limits
ax.set_ylim(-1.5, 1.5)

# Add labels and title
ax.set_xlabel('X-axis')
ax.set_ylabel('Y-axis')
ax.set_title('Sine Wave with Custom Y-axis Limits - how2matplotlib.com')

# Display the plot
plt.show()

# Print output
print("The plot with custom y-axis limits has been displayed.")

Output:

In this example, we use ax.set_ylim(-1.5, 1.5) to set the y-axis limits from -1.5 to 1.5. This extends the y-axis range beyond the natural limits of the sine function (-1 to 1), providing more context to the plot.

Combining Matplotlib Subplots and ylim

Now, let’s combine our knowledge of subplots and ylim to create more complex visualizations. We’ll create a figure with multiple subplots, each with its own y-axis limits.

import matplotlib.pyplot as plt
import numpy as np

# Create a 2x2 grid of subplots
fig, axs = plt.subplots(2, 2, figsize=(12, 10))

# Generate sample data
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)
y3 = np.exp(-x/10)
y4 = x**2

# Plot data on each subplot with custom y-axis limits
axs[0, 0].plot(x, y1)
axs[0, 0].set_title('Sine Wave')
axs[0, 0].set_ylim(-1.5, 1.5)

axs[0, 1].plot(x, y2)
axs[0, 1].set_title('Cosine Wave')
axs[0, 1].set_ylim(-2, 2)

axs[1, 0].plot(x, y3)
axs[1, 0].set_title('Exponential Decay')
axs[1, 0].set_ylim(0, 1.2)

axs[1, 1].plot(x, y4)
axs[1, 1].set_title('Quadratic Function')
axs[1, 1].set_ylim(0, 120)

# Add a main title
fig.suptitle('Matplotlib Subplots with Custom Y-axis Limits - how2matplotlib.com', fontsize=16)

# Adjust layout and display the plot
plt.tight_layout()
plt.show()

# Print output
print("The plot with multiple subplots and custom y-axis limits has been displayed.")

Output:

In this example, we create a 2×2 grid of subplots and set custom y-axis limits for each subplot using axs[i, j].set_ylim(). This allows us to optimize the display of each plot individually.

Advanced Techniques with Matplotlib Subplots and ylim

Now that we’ve covered the basics, let’s explore some advanced techniques for working with Matplotlib subplots and ylim.

1. Sharing Axes Among Subplots

Sometimes, you may want to share axes among subplots to facilitate comparison. Matplotlib allows you to share x-axes, y-axes, or both.

import matplotlib.pyplot as plt
import numpy as np

# Create subplots with shared axes
fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(8, 10), sharex=True)

# Generate sample data
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)
y3 = np.tan(x)

# Plot data on each subplot
ax1.plot(x, y1)
ax1.set_title('Sine Wave')
ax1.set_ylim(-1.5, 1.5)

ax2.plot(x, y2)
ax2.set_title('Cosine Wave')
ax2.set_ylim(-1.5, 1.5)

ax3.plot(x, y3)
ax3.set_title('Tangent Wave')
ax3.set_ylim(-10, 10)

# Add a main title
fig.suptitle('Subplots with Shared X-axis - how2matplotlib.com', fontsize=16)

# Adjust layout and display the plot
plt.tight_layout()
plt.show()

# Print output
print("The plot with shared x-axis has been displayed.")

Output:

In this example, we use sharex=True when creating the subplots to share the x-axis among all subplots. This ensures that the x-axis range is the same for all plots, making it easier to compare the different functions.

2. Using Twin Axes

Sometimes, you may want to plot two different scales on the same subplot. Matplotlib allows you to create twin axes for this purpose.

import matplotlib.pyplot as plt
import numpy as np

# Create a figure and primary axes
fig, ax1 = plt.subplots(figsize=(10, 6))

# Generate sample data
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.exp(x)

# Plot data on primary axes
ax1.plot(x, y1, 'b-', label='Sine Wave')
ax1.set_xlabel('X-axis')
ax1.set_ylabel('Sine', color='b')
ax1.tick_params(axis='y', labelcolor='b')
ax1.set_ylim(-1.5, 1.5)

# Create twin axes
ax2 = ax1.twinx()
ax2.plot(x, y2, 'r-', label='Exponential')
ax2.set_ylabel('Exponential', color='r')
ax2.tick_params(axis='y', labelcolor='r')
ax2.set_ylim(0, 25000)

# Add a title
plt.title('Twin Axes Example - how2matplotlib.com')

# Add legend
lines1, labels1 = ax1.get_legend_handles_labels()
lines2, labels2 = ax2.get_legend_handles_labels()
ax1.legend(lines1 + lines2, labels1 + labels2, loc='upper left')

# Display the plot
plt.tight_layout()
plt.show()

# Print output
print("The plot with twin axes has been displayed.")

Output:

In this example, we create a primary set of axes (ax1) and a twin set of axes (ax2) using ax1.twinx(). This allows us to plot two different scales on the same subplot, with the left y-axis showing the sine wave and the right y-axis showing the exponential function.

3. Adjusting Y-axis Limits Dynamically

Sometimes, you may want to adjust the y-axis limits based on the data being plotted. Here’s an example of how to do this dynamically:

import matplotlib.pyplot as plt
import numpy as np

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

# Generate sample data
x = np.linspace(0, 10, 100)
y = np.sin(x) * np.random.randn(100)

# Plot the data
ax.plot(x, y)

# Get the current y-axis limits
y_min, y_max = ax.get_ylim()

# Add some padding to the y-axis limits
padding = (y_max - y_min) * 0.1
new_y_min = y_min - padding
new_y_max = y_max + padding

# Set the new y-axis limits
ax.set_ylim(new_y_min, new_y_max)

# Add labels and title
ax.set_xlabel('X-axis')
ax.set_ylabel('Y-axis')
ax.set_title('Dynamic Y-axis Limits - how2matplotlib.com')

# Display the plot
plt.tight_layout()
plt.show()

# Print output
print("The plot with dynamically adjusted y-axis limits has been displayed.")

Output:

In this example, we first plot the data and then get the current y-axis limits using ax.get_ylim(). We then add some padding to these limits and set the new limits using ax.set_ylim(). This ensures that the data fits comfortably within the plot area.

4. Creating Subplots with Different Scales

Sometimes, you may want to create subplots with different scales to highlight different aspects of your data. Here’s an example:

import matplotlib.pyplot as plt
import numpy as np

# Create a figure with 2x2 subplots
fig, axs = plt.subplots(2, 2, figsize=(12, 10))

# Generate sample data
x = np.linspace(0, 10, 100)
y = np.sin(x)

# Plot the same data with different y-axis scales
axs[0, 0].plot(x, y)
axs[0, 0].set_title('Default Scale')

axs[0, 1].plot(x, y)
axs[0, 1].set_title('Zoomed In')
axs[0, 1].set_ylim(-0.5, 0.5)

axs[1, 0].plot(x, y)
axs[1, 0].set_title('Full Range')
axs[1, 0].set_ylim(-1, 1)

axs[1, 1].plot(x, y)
axs[1, 1].set_title('Extended Range')
axs[1, 1].set_ylim(-2, 2)

# Add a main title
fig.suptitle('Subplots with Different Y-axis Scales - how2matplotlib.com', fontsize=16)

# Adjust layout and display the plot
plt.tight_layout()
plt.show()

# Print output
print("The plot with subplots of different scales has been displayed.")

Output:

In this example, we create four subplots, each showing the same sine wave but with different y-axis scales. This allows us to highlight different aspects of the data, such as zooming in on a particular region or showing the full range of the function.

5. Using Logarithmic Scales

For data that spans multiple orders of magnitude, it can be useful to use logarithmic scales. Matplotlib allows you to easily set logarithmic scales for both x and y axes.

import matplotlib.pyplot as plt
import numpy as np

# Create a figure with 2x2 subplots
fig, axs = plt.subplots(2, 2, figsize=(12, 10))

# Generate sample data
x = np.logspace(0, 3, 50)
y = x**2

# Linear scale
axs[0, 0].plot(x, y)
axs[0, 0].set_title('Linear Scale')

# Log-Log scale
axs[0, 1].loglog(x, y)
axs[0, 1].set_title('Log-Log Scale')

# Semi-log scale (x-axis)
axs[1, 0].semilogx(x, y)
axs[1, 0].set_title('Semi-log Scale (X-axis)')

# Semi-log scale (y-axis)
axs[1, 1].semilogy(x, y)
axs[1, 1].set_title('Semi-log Scale (Y-axis)')

# Add a main title
fig.suptitle('Subplots with Different Scale Types - how2matplotlib.com', fontsize=16)

# Adjust layout and display the plot
plt.tight_layout()
plt.show()

# Print output
print("The plot with different scale types has been displayed.")

Output:

In this example, we create four subplots, each showing the same quadratic function but with different scale types:
1. Linear scale (default)
2. Log-Log scale (both x and y axes are logarithmic)
3. Semi-log scale with logarithmic x-axis
4. Semi-log scale with logarithmic y-axis

This demonstrates how different scale types can reveal different aspects of the data, especially when dealing with exponential growth or decay.

Advanced Customization of Matplotlib Subplots and ylim

Now that we’ve covered various techniques for working with subplots and ylim, let’s explore some advanced customization options to make your plots even more informative and visually appealing.

1. Adding Colorbar to Subplots

When working with 2D data or heatmaps, it’s often useful to add a colorbar to your subplots. Here’s an example of how to do this:

import matplotlib.pyplot as plt
import numpy as np

# Create a figure with 2x2 subplots
fig, axs = plt.subplots(2, 2, figsize=(12, 10))

# Generate sample 2D data
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)
Z1 = np.sin(np.sqrt(X**2 + Y**2))
Z2 = np.cos(np.sqrt(X**2 + Y**2))

# Plot heatmaps with colorbars
im1 = axs[0, 0].imshow(Z1, cmap='viridis', extent=[-5, 5, -5, 5])
axs[0, 0].set_title('Sine Heatmap')
fig.colorbar(im1, ax=axs[0, 0])

im2 = axs[0, 1].imshow(Z2, cmap='plasma', extent=[-5, 5, -5, 5])
axs[0, 1].set_title('Cosine Heatmap')
fig.colorbar(im2, ax=axs[0, 1])

# Plot contour maps with colorbars
cs1 = axs[1, 0].contourf(X, Y, Z1, cmap='coolwarm')
axs[1, 0].set_title('Sine Contour')
fig.colorbar(cs1, ax=axs[1, 0])

cs2 = axs[1, 1].contourf(X, Y, Z2, cmap='RdYlBu')
axs[1, 1].set_title('Cosine Contour')
fig.colorbar(cs2, ax=axs[1, 1])

# Add a main title
fig.suptitle('Subplots with Colorbars - how2matplotlib.com', fontsize=16)

# Adjust layout and display the plot
plt.tight_layout()
plt.show()

# Print output
print("The plot with colorbars has been displayed.")

Output:

In this example, we create four subplots showing different representations of 2D data: heatmaps and contour plots. We add a colorbar to each subplot using fig.colorbar(), which helps interpret the color scales used in the plots.

2. Customizing Tick Labels and Gridlines

To improve the readability of your plots, you can customize tick labels and add gridlines. Here’s an example:

import matplotlib.pyplot as plt
import numpy as np

# Create a figure with 2x2 subplots
fig, axs = plt.subplots(2, 2, figsize=(12, 10))

# Generate sample data
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)

# Customize first subplot
axs[0, 0].plot(x, y1)
axs[0, 0].set_title('Custom Ticks')
axs[0, 0].set_xticks(np.arange(0, 11, 2))
axs[0, 0].set_yticks(np.arange(-1, 1.1, 0.5))
axs[0, 0].set_ylim(-1.2, 1.2)

# Customize second subplot
axs[0, 1].plot(x, y2)
axs[0, 1].set_title('Custom Grid')
axs[0, 1].grid(True, linestyle='--', alpha=0.7)
axs[0, 1].set_ylim(-1.2, 1.2)

# Customize third subplot
axs[1, 0].plot(x, y1)
axs[1, 0].set_title('Custom Tick Labels')
axs[1, 0].set_xticks(np.arange(0, 11, 2))
axs[1, 0].set_xticklabels(['Zero', 'Two', 'Four', 'Six', 'Eight', 'Ten'])
axs[1, 0].set_ylim(-1.2, 1.2)

# Customize fourth subplot
axs[1, 1].plot(x, y2)
axs[1, 1].set_title('Minor Ticks')
axs[1, 1].set_ylim(-1.2, 1.2)
axs[1, 1].minorticks_on()

# Add a main title
fig.suptitle('Customized Ticks and Gridlines - how2matplotlib.com', fontsize=16)

# Adjust layout and display the plot
plt.tight_layout()
plt.show()

# Print output
print("The plot with customized ticks and gridlines has been displayed.")

Output:

In this example, we demonstrate various ways to customize ticks and gridlines:
1. Setting custom tick positions
2. Adding a custom grid
3. Using custom tick labels
4. Displaying minor ticks

These customizations can greatly enhance the readability and professional appearance of your plots.

3. Adding Annotations and Text to Subplots

Adding annotations and text to your plots can provide additional context and highlight important features. Here’s an example:

import matplotlib.pyplot as plt
import numpy as np

# Create a figure with 2x2 subplots
fig, axs = plt.subplots(2, 2, figsize=(12, 10))

# Generate sample data
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)

# First subplot: Adding text
axs[0, 0].plot(x, y1)
axs[0, 0].set_title('Adding Text')
axs[0, 0].text(5, 0.5, 'Sine Wave', fontsize=12, ha='center')
axs[0, 0].set_ylim(-1.2, 1.2)

# Second subplot: Adding arrows
axs[0, 1].plot(x, y2)
axs[0, 1].set_title('Adding Arrows')
axs[0, 1].annotate('Local Maximum', xy=(1.5, 1), xytext=(3, 0.5),
                   arrowprops=dict(facecolor='black', shrink=0.05))
axs[0, 1].set_ylim(-1.2, 1.2)

# Third subplot: Adding a legend
axs[1, 0].plot(x, y1, label='Sine')
axs[1, 0].plot(x, y2, label='Cosine')
axs[1, 0].set_title('Adding a Legend')
axs[1, 0].legend()
axs[1, 0].set_ylim(-1.2, 1.2)

# Fourth subplot: Adding a text box
axs[1, 1].plot(x, y1)
axs[1, 1].set_title('Adding a Text Box')
props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
axs[1, 1].text(5, 0.5, 'Important\nInformation', fontsize=10,
               verticalalignment='top', bbox=props)
axs[1, 1].set_ylim(-1.2, 1.2)

# Add a main title
fig.suptitle('Annotations and Text in Subplots - how2matplotlib.com', fontsize=16)

# Adjust layout and display the plot
plt.tight_layout()
plt.show()

# Print output
print("The plot with annotations and text has been displayed.")

Output:

In this example, we demonstrate various ways to add annotations and text to your plots:
1. Adding simple text
2. Adding arrows to point out features
3. Adding a legend
4. Adding a text box with a background

These annotations can help guide the viewer’s attention to important aspects of your data or provide additional context.

Handling Large Datasets with Matplotlib Subplots and ylim

When working with large datasets, it’s important to optimize your plots for both performance and readability. Here are some techniques to handle large datasets effectively:

1. Using plt.plot() vs. plt.scatter()

For large datasets, plt.plot() is generally faster than plt.scatter(). Here’s an example comparing the two:

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

# Generate a large dataset
np.random.seed(0)
n_points = 100000
x = np.random.rand(n_points)
y = np.random.rand(n_points)

# Create a figure with 1x2 subplots
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))

# Plot using plt.plot()
start_time = time.time()
ax1.plot(x, y, 'o', markersize=1)
ax1.set_title(f'plt.plot() - {n_points:,} points')
ax1.set_ylim(0, 1)
plot_time = time.time() - start_time

# Plot using plt.scatter()
start_time = time.time()
ax2.scatter(x, y, s=1)
ax2.set_title(f'plt.scatter() - {n_points:,} points')
ax2.set_ylim(0, 1)
scatter_time = time.time() - start_time

# Add a main title
fig.suptitle('Comparing plt.plot() and plt.scatter() - how2matplotlib.com', fontsize=16)

# Adjust layout and display the plot
plt.tight_layout()
plt.show()

# Print output
print(f"plt.plot() took {plot_time:.4f} seconds")
print(f"plt.scatter() took {scatter_time:.4f} seconds")

Output:

In this example, we plot a large dataset of 100,000 points using both plt.plot() and plt.scatter(). You’ll notice that plt.plot() is significantly faster, especially for large datasets.

2. Using Downsampling Techniques

When dealing with extremely large datasets, it can be helpful to downsample the data before plotting. Here’s an example using random sampling:

import matplotlib.pyplot as plt
import numpy as np

# Generate a large dataset
np.random.seed(0)
n_points = 1000000
x = np.random.rand(n_points)
y = np.random.rand(n_points)

# Create a figure with 1x2 subplots
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))

# Plot full dataset
ax1.plot(x, y, 'o', markersize=1)
ax1.set_title(f'Full Dataset - {n_points:,} points')
ax1.set_ylim(0, 1)

# Downsample and plot
sample_size = 10000
indices = np.random.choice(n_points, sample_size, replace=False)
ax2.plot(x[indices], y[indices], 'o', markersize=1)
ax2.set_title(f'Downsampled - {sample_size:,} points')
ax2.set_ylim(0, 1)

# Add a main title
fig.suptitle('Downsampling Large Datasets - how2matplotlib.com', fontsize=16)

# Adjust layout and display the plot
plt.tight_layout()
plt.show()

# Print output
print(f"Original dataset: {n_points:,} points")
print(f"Downsampled dataset: {sample_size:,} points")

Output:

In this example, we generate a dataset with 1 million points and then create two plots: one with the full dataset and another with a randomly downsampled subset of 10,000 points. This technique can significantly improve plotting performance while still providing a representative view of the data.

3. Using Alpha Blending for Dense Scatterplots

When plotting dense scatterplots, it can be difficult to see the distribution of points. Using alpha blending can help visualize the density of points:

import matplotlib.pyplot as plt
import numpy as np

# Generate a large dataset with clusters
np.random.seed(0)
n_points = 100000
cluster_centers = [(0.2, 0.2), (0.8, 0.8)]
x = np.concatenate([np.random.normal(cx, 0.1, n_points//2) for cx, _ in cluster_centers])
y = np.concatenate([np.random.normal(cy, 0.1, n_points//2) for _, cy in cluster_centers])

# Create a figure with 1x2 subplots
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))

# Plot without alpha blending
ax1.plot(x, y, 'o', markersize=1)
ax1.set_title('Without Alpha Blending')
ax1.set_ylim(0, 1)

# Plot with alpha blending
ax2.plot(x, y, 'o', markersize=1, alpha=0.1)
ax2.set_title('With Alpha Blending')
ax2.set_ylim(0, 1)

# Add a main title
fig.suptitle('Alpha Blending for Dense Scatterplots - how2matplotlib.com', fontsize=16)

# Adjust layout and display the plot
plt.tight_layout()
plt.show()

# Print output
print(f"Number of points plotted: {n_points:,}")

Output:

In this example, we generate a large dataset with two clusters and plot it twice: once without alpha blending and once with alpha blending. The plot with alpha blending (alpha=0.1) allows us to see the density of points more clearly, revealing the structure of the two clusters.

Advanced Matplotlib Subplots and ylim Techniques

Let’s explore some more advanced techniques for working with Matplotlib subplots and ylim.

1. Creating Subplots with Unequal Sizes

Sometimes, you may want to create subplots of different sizes within the same figure. Here’s how you can achieve this:

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

# Create a figure
fig = plt.figure(figsize=(12, 8))

# Create a custom grid
gs = gridspec.GridSpec(2, 2, width_ratios=[2, 1], height_ratios=[1, 2])

# Generate sample data
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)
y3 = np.tan(x)
y4 = x**2

# Create subplots with different sizes
ax1 = fig.add_subplot(gs[0, 0])
ax1.plot(x, y1)
ax1.set_title('Larger Width')
ax1.set_ylim(-1.5, 1.5)

ax2 = fig.add_subplot(gs[0, 1])
ax2.plot(x, y2)
ax2.set_title('Smaller Width')
ax2.set_ylim(-1.5, 1.5)

ax3 = fig.add_subplot(gs[1, :])
ax3.plot(x, y3)
ax3.set_title('Full Width')
ax3.set_ylim(-10, 10)

# Add a main title
fig.suptitle('Subplots with Unequal Sizes - how2matplotlib.com', fontsize=16)

# Adjust layout and display the plot
plt.tight_layout()
plt.show()

# Print output
print("The plot with unequal subplot sizes has been displayed.")

Output:

In this example, we use matplotlib.gridspec.GridSpec to create a custom grid layout. We specify different width and height ratios for the columns and rows, allowing us to create subplots of varying sizes.

2. Creating Inset Axes

Inset axes are useful when you want to show a zoomed-in view of a particular region of your plot. Here’s how to create inset axes:

import matplotlib.pyplot as plt
import numpy as np

# Generate sample data
x = np.linspace(0, 10, 1000)
y = np.sin(x) + 0.1 * np.random.randn(1000)

# Create main plot
fig, ax = plt.subplots(figsize=(10, 6))
ax.plot(x, y)
ax.set_title('Main Plot with Inset Axes - how2matplotlib.com')
ax.set_ylim(-1.5, 1.5)

# Create inset axes
axins = ax.inset_axes([0.5, 0.5, 0.47, 0.47])
axins.plot(x, y)
axins.set_xlim(4, 6)
axins.set_ylim(-0.5, 0.5)
axins.set_xticklabels([])
axins.set_yticklabels([])

# Add a rectangle patch to indicate the zoomed region
ax.indicate_inset_zoom(axins, edgecolor="black")

# Display the plot
plt.show()

# Print output
print("The plot with inset axes has been displayed.")

Output:

In this example, we create a main plot and then add an inset axes using ax.inset_axes(). The inset axes show a zoomed-in view of a specific region of the main plot. We use ax.indicate_inset_zoom() to draw a rectangle on the main plot indicating the zoomed region.

3. Creating 3D Subplots

Matplotlib also supports 3D plotting. Here’s an example of creating 3D subplots:

import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.mplot3d import Axes3D

# Generate sample data
x = np.linspace(-5, 5, 50)
y = np.linspace(-5, 5, 50)
X, Y = np.meshgrid(x, y)
Z1 = np.sin(np.sqrt(X**2 + Y**2))
Z2 = np.cos(np.sqrt(X**2 + Y**2))

# Create figure and 3D subplots
fig = plt.figure(figsize=(12, 5))
ax1 = fig.add_subplot(121, projection='3d')
ax2 = fig.add_subplot(122, projection='3d')

# Plot 3D surfaces
surf1 = ax1.plot_surface(X, Y, Z1, cmap='viridis')
ax1.set_title('3D Sine Surface')
ax1.set_zlim(-1, 1)

surf2 = ax2.plot_surface(X, Y, Z2, cmap='plasma')
ax2.set_title('3D Cosine Surface')
ax2.set_zlim(-1, 1)

# Add colorbars
fig.colorbar(surf1, ax=ax1, shrink=0.5, aspect=10)
fig.colorbar(surf2, ax=ax2, shrink=0.5, aspect=10)

# Add a main title
fig.suptitle('3D Subplots - how2matplotlib.com', fontsize=16)

# Adjust layout and display the plot
plt.tight_layout()
plt.show()

# Print output
print("The 3D subplots have been displayed.")

Output:

In this example, we create two 3D subplots using projection='3d' when adding subplots. We then use plot_surface() to create 3D surface plots of sine and cosine functions.

Matplotlib subplots ylim Conclusion

In this comprehensive guide, we’ve explored a wide range of techniques for working with Matplotlib subplots and ylim. From basic plot creation to advanced customization and handling of large datasets, you now have the tools to create informative and visually appealing plots for your data analysis and visualization needs.

Remember that Matplotlib is a powerful and flexible library, and there’s always more to learn. Experiment with different combinations of these techniques to find the best way to visualize your specific data and tell your data story effectively.

As you continue to work with Matplotlib, don’t forget to refer to the official documentation and community resources for more advanced techniques and up-to-date best practices. Happy plotting!