I agree it will be nice. This particular case will be tricky -- the view limit object is created before and without any knowledge of the input data datatype...

Perhaps not directly related but this issue was the closest I could find:

I'd like axvline to accept numpy array as first argument, along these lines:

In [2]: import numpy as np
In [3]: x = np.linspace(-10, 10); y = np.sin(x)
In [4]: plt.plot(x, y); plt.axvline(x); plt.show()
...
ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

now I have to resort to:

In [6]: for _x in x:
   ...:     plt.axvline(_x)
   ...:     

when x is very long I set alpha to e.g. 0.1 (x is not equidistant in that case of course).
Unfortunately this is really slow in matplotlib (when x is a few thousand elements running times
are counted in minutes). Are there any opportunities to make this faster? (or maybe I am approaching this the wrong way?)

@bjodah I think you are looking for the ax.vlines method http://matplotlib.org/api/_as_gen/matplotlib.axes.Axes.vlines.html#matplotlib.axes.Axes.vlines

@tacaswell well kind of, but using ymin/ymax: (-inf, inf) does not work:

>>> import matplotlib.pyplot as plt; import numpy as np;
>>> x = np.linspace(-5, 5); y = np.sin(x); plt.vlines(x, float('-inf'), float('inf')); plt.plot(x, y); plt.show()

(plot shows no vertical lines)

then I need to compute ymin, ymax from the maximum/minimum values of all series which will be plotted later, or use a priori information:

>>> x = np.linspace(-5, 5); y = np.sin(x); plt.vlines(x, -1, 1); plt.plot(x, y); plt.show()

(edit: axvline guarantees to draw the lines across the axes, vlines affects ylim which is not what I want for this particular case).

Use it in conjunction with a blended transform: http://matplotlib.org/users/transforms_tutorial.html#blended-transformations and go from 0 to 1 in axes space.

@tacaswell thank you, very neat! For future visitors from e.g. google:

import numpy as np; import matplotlib.pyplot as plt;
import matplotlib.transforms as tf
x = np.linspace(-5, 5); y = np.sin(x); ax = plt.subplot(1, 1, 1);
trans = tf.blended_transform_factory(ax.transData, ax.transAxes)
ax.vlines(x, 0, 1, transform=trans); ax.plot(x, y); plt.show()

... and performance is much better!

that is probably worth an example in the docs. I have seen this question come across multiple times in multiple places.

axhline/axvline with AstroPy quantities works with astropy/astropy#7037, and I suspect lots of other stuff will start working if that pull request is accepted too.

This issue has been marked "inactive" because it has been 365 days since the last comment. If this issue is still present in recent Matplotlib releases, or the feature request is still wanted, please leave a comment and this label will be removed. If there are no updates in another 30 days, this issue will be automatically closed, but you are free to re-open or create a new issue if needed. We value issue reports, and this procedure is meant to help us resurface and prioritize issues that have not been addressed yet, not make them disappear. Thanks for your help!

Closing as the original issue was fixed downstream. There are plenty of areas where units support could be improved in similar ways (and the data prototype work plays into that), but this particular report is no longer a problem, I think