### Introduction

*Matplotlib* is one of the most widely used data visualization libraries in Python. Much of Matplotlib's popularity comes from its customization options - you can tweak just about any element from its *hierarchy of objects*.

In this tutorial, we'll take a look at *how to draw a vertical line on a Matplotlib plot*, that allows us to mark and highlight certain regions of the plot, without zooming or changing the axis range.

### Creating a Plot

Let's first create a simple plot with some random data:

```
import matplotlib.pyplot as plt
import numpy as np
fig, ax = plt.subplots(figsize=(12, 6))
np.random.seed(42)
x = np.random.rand(150)
ax.plot(x)
plt.show()
```

Here, we've used NumPy to generate 150 random data points, in a range of `[0, 1)`

.

Now, since we've set a `seed`

, we can replicate this random image as many times as we'd like. For example, let's draw vertical lines on the `20`

and `100`

marks.

There are two ways we can draw lines, using the `vlines()`

or `axvline()`

functions of the PyPlot instance. Naturally, you can also call these methods on the `Axes`

object.

### Draw Vertical Lines on Matplotlib Plot with *PyPlot.vlines()*

Let's start off with the `vlines()`

function:

```
import matplotlib.pyplot as plt
import numpy as np
fig, ax = plt.subplots(figsize=(12, 6))
np.random.seed(42)
x = np.random.rand(150)
ax.plot(x)
ax.vlines([20, 100], 0, 1, linestyles='dashed', colors='red')
plt.show()
```

The `vlines()`

function accepts a few arguments - a scalar, or 1D array of X-values that you'd like to draw lines on. We've supplied `[20, 100]`

, marking two points, though you can go from `0..n`

points here. Then, the `ymin`

and `ymax`

arguments - these are the *height* of the lines. We've set them to be from `0`

to `1`

, since that's the distribution of the `np.random.rand()`

call as well. Then, you can set styles, such as `linestyles`

or `colors`

, which accept the typical Matplotlib styling options.

Running this code will result in:

We've got two vertical lines, which are dashed, in red color, at the `20`

and `100`

points on the X-axis.

This function allows us to set the `ymin`

and `ymax`

in concrete values, while `axvline()`

lets us choose the height percentage-wise, or we simply let it plot from the bottom to the top by default.

This feature comes in handy when you'd like to make the lines shorter or longer, for example. Let's change the range of our Y-axis, to include the view from `-10`

to `10`

, instead of `0`

and `1`

. Our random data will still be in the range from `[0, 1)`

so we'll have a better look at it from a different perspective:

```
fig, ax = plt.subplots(figsize=(12, 6))
np.random.seed(42)
x = np.random.rand(150)
ax.plot(x)
ax.set_ylim(-10, 10)
ax.vlines([20, 100], -2, 2, linestyles='dashed', colors='red')
```

Here, we've set the lines to be longer than the range of the random data itself, but still much smaller than the size of the `Axes`

itself.

### Draw Vertical Lines on Matplotlib Plot with *PyPlot.axvline()*

Now, let's take a look at the `axvline()`

function:

```
fig, ax = plt.subplots(figsize=(12, 6))
np.random.seed(42)
x = np.random.rand(150)
ax.plot(x)
ax.set_ylim(-10, 10)
ax.axvline(20, color='red')
ax.axvline(100, color='red')
plt.show()
```

It has a few limitations that the other function doesn't have, such as being able to only plot on a single point at a time. If we want to plot on multiple points, such as `20`

and `100`

, we'll have to call the function twice.

It also doesn't really let us specify the `linestyle`

like `vlines()`

let us, though, it doesn't require the `ymin`

and `ymax`

arguments by default. If you omit them, like we have, they'll simply be from the top to the bottom of the `Axes`

:

## 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!

However, you can change the height if you'd like - this time around though, you'll change the height in terms of percentages. These percentages take the top and bottom of the `Axes`

into consideration so 0% will be at the very bottom, while 100% will be at the very top. Let's draw a line spanning from 50% to 80%:

```
fig, ax = plt.subplots(figsize=(12, 6))
np.random.seed(42)
x = np.random.rand(150)
ax.plot(x)
ax.set_ylim(-10, 10)
ax.axvline(20, 0.8, 0.5, color='red')
ax.axvline(100, 0.8, 0.5, color='red')
```

This produces:

### Conclusion

In this tutorial, we've gone over *how to draw vertical lines on a Matplotlib Plot*.

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 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.