Matplotlib is one of the most widely used data visualization libraries in Python. From simple to complex visualizations, it's the go-to library for most.
In this tutorial, we'll take a look at how to plot multiple line plots in Matplotlib - on the same
If you'd like to read more about plotting line plots in general, as well as customizing them, make sure to read our guide on Plotting Lines Plots with Matplotlib.
Plot Multiple Line Plots in Matplotlib
Depending on the style you're using, OOP or MATLAB-style, you'll either use the
plt instance, or the
ax instance to plot, with the same approach.
To plot multiple line plots in Matplotlib, you simply repeatedly call the
plot() function, which will apply the changes to the same
import matplotlib.pyplot as plt x = [1, 2, 3, 4, 5, 6] y = [2, 4, 6, 5, 6, 8] y2 = [5, 3, 7, 8, 9, 6] fig, ax = plt.subplots() ax.plot(x, y) ax.plot(x, y2) plt.show()
Without setting any customization flags, the default colormap will apply, drawing both line plots on the same
Figure object, and adjusting the color to differentiate between them:
Now, let's generate some random sequences using NumPy, and customize the line plots a tiny bit by setting a specific color for each, and labeling them:
import matplotlib.pyplot as plt import numpy as np line_1 = np.random.randint(low = 0, high = 50, size = 50) line_2 = np.random.randint(low = -15, high = 100, size = 50) fig, ax = plt.subplots() ax.plot(line_1, color = 'green', label = 'Line 1') ax.plot(line_2, color = 'red', label = 'Line 2') ax.legend(loc = 'upper left') plt.show()
We don't have to supply the X-axis values to a line plot, in which case, the values from
0..n will be applied, where
n is the last element in the data you're plotting. In our case, we've got two sequences of data -
line_2, which will both be plotted on the same X-axis.
While plotting, we've assigned colors to them, using the
color argument, and labels for the legend, using the
label argument. This results in:
Plot Multiple Line Plots with Different Scales
Sometimes, you might have two datasets, fit for line plots, but their values are significantly different, making it hard to compare both lines. For example, if
line_1 had an exponentially increasing sequence of numbers, while
line_2 had a linearly increasing sequence - surely and quickly enough,
line_1 would have values so much larger than
line_2, that the latter fades out of view.
Let's use NumPy to make an exponentially increasing sequence of numbers, and plot it next to another line on the same
import matplotlib.pyplot as plt import numpy as np linear_sequence = np.linspace(0, 10, 10) # [0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 10] exponential_sequence = np.exp(linear_sequence) # [1.00e+00, 3.03e+00, 9.22e+00, 2.80e+01, 8.51e+01, 2.58e+02, 7.85e+02, 2.38e+03, 7.25e+03, 2.20e+04] fig, ax = plt.subplots() ax.plot(linear_sequence) ax.plot(exponential_sequence) plt.show()
Running this code results in:
The exponential growth in the
exponential_sequence goes out of proportion very fast, and it looks like there's absolutely no difference in the
linear_sequence, since it's so minuscule relative to the exponential trend of the other sequence.
Now, let's plot the
exponential_sequence on a logarithmic scale, which will produce a visually straight line, since the Y-scale will exponentially increase. If we plot it on a logarithmic scale, and the
linear_sequence just increases by the same constant, we'll have two overlapping lines and we will only be able to see the one plotted after the first.
Free eBook: Git Essentials
Check out our hands-on, practical guide to learning Git, with best-practices, industry-accepted standards, and included cheat sheet. Stop Googling Git commands and actually learn it!
Let's change up the
linear_sequence a bit to make it observable once we plot both:
import matplotlib.pyplot as plt import numpy as np # Sequences linear_sequence = [1, 2, 3, 4, 5, 6, 7, 10, 15, 20] exponential_sequence = np.exp(np.linspace(0, 10, 10)) fig, ax = plt.subplots() # Plot linear sequence, and set tick labels to the same color ax.plot(linear_sequence, color='red') ax.tick_params(axis='y', labelcolor='red') # Generate a new Axes instance, on the twin-X axes (same position) ax2 = ax.twinx() # Plot exponential sequence, set scale to logarithmic and change tick color ax2.plot(exponential_sequence, color='green') ax2.set_yscale('log') ax2.tick_params(axis='y', labelcolor='green') plt.show()
This time around, we'll have to use the OOP interface, since we're creating a new
Axes instance. One
Axes has one scale, so we create a new one, in the same position as the first one, and set its scale to a logarithmic one, and plot the exponential sequence.
This results in:
We've also changed the tick label colors to match the color of the line plots themselves, otherwise, it'd be hard to distinguish which line is on which scale.
Plot Multiple Line Plots with Multiple Y-Axis
Finally, we can apply the same scale (linear, logarithmic, etc), but have different values on the Y-axis of each line plot. This is achieved through having multiple Y-axis, on different
Axes objects, in the same position.
For example, the
linear_sequence won't go above 20 on the Y-axis, while the
exponential_sequence will go up to 20000. We can plot them both linearly, simply by plotting them on different
Axes objects, in the same position, each of which set the Y-axis ticks automatically to accommodate for the data we're feeding in:
import matplotlib.pyplot as plt import numpy as np # Sequences linear_sequence = [1, 2, 3, 4, 5, 6, 7, 10, 15, 20] exponential_sequence = np.exp(np.linspace(0, 10, 10)) fig, ax = plt.subplots() # Plot linear sequence, and set tick labels to the same color ax.plot(linear_sequence, color='red') ax.tick_params(axis='y', labelcolor='red') # Generate a new Axes instance, on the twin-X axes (same position) ax2 = ax.twinx() # Plot exponential sequence, set scale to logarithmic and change tick color ax2.plot(exponential_sequence, color='green') ax2.tick_params(axis='y', labelcolor='green') plt.show()
We've again created another
Axes in the same position as the first one, so we can plot on the same place in the
Figure but different
Axes objects, which allows us to set values for each Y-axis individually.
Without setting the Y-scale to logarithmic this time, both will be plotted linearly:
In this tutorial, we've gone over how to plot multiple Line Plots on the same
Axes in Matplotlib and Python. We've covered how to plot on the same
Axes with the same scale and Y-axis, as well as how to plot on the same
Figure with different and identical Y-axis scales.
If you're interested in Data Visualization and don't know where to start, make sure to check out our bundle of books on Data Visualization in Python:
Data Visualization in Python
Become dangerous with Data Visualization
✅ 30-day no-question money-back guarantee
✅ Beginner to Advanced
✅ Updated regularly for free (latest update in April 2021)
✅ Updated with bonus resources and guides
Data Visualization in Python with Matplotlib and Pandas is a book designed to take absolute beginners to Pandas and Matplotlib, with basic Python knowledge, and allow them to build a strong foundation for advanced work with these libraries - from simple plots to animated 3D plots with interactive buttons.
It serves as an in-depth guide that'll teach you everything you need to know about Pandas and Matplotlib, including how to construct plot types that aren't built into the library itself.
Data Visualization in Python, a book for beginner to intermediate Python developers, guides you through simple data manipulation with Pandas, covers core plotting libraries like Matplotlib and Seaborn, and shows you how to take advantage of declarative and experimental libraries like Altair. More specifically, over the span of 11 chapters this book covers 9 Python libraries: Pandas, Matplotlib, Seaborn, Bokeh, Altair, Plotly, GGPlot, GeoPandas, and VisPy.
It serves as a unique, practical guide to Data Visualization, in a plethora of tools you might use in your career.