Note
Go to the endto download the full example code.
Coding shortcuts#
Matplotlib's primary and universal API is theAxes interface.While it is clearly structured and powerful, it can sometimes feel overly verbose andthus cumbersome to write. This page collects patterns for condensing the codeof the Axes-based API and achieving the same results with less typing for many simplerplots.
Note
Thepyplot interface is an alternative more compactinterface, and was historically modeled to be similar to MATLAB. It remains avalid approach for those who want to use it. However, it has the disadvantage thatit achieves its brevity through implicit assumptions that you have to understand.
Since it follows a different paradigm, switching between the Axes interface andthe pyplot interface requires a shift of the mental model, and some code rewrite,if the code develops to a point at which pyplot no longer provides enoughflexibility.
This tutorial goes the other way round, starting from the standard verbose Axesinterface and using its capabilities for shortcuts when you don't need all thegenerality.
Let's assume we want to make a plot of the number of daylight hours per day over theyear in London.
The standard approach with the Axes interface looks like this.
importmatplotlib.pyplotaspltimportnumpyasnpday=np.arange(365)hours=4.276*np.sin(2*np.pi*(day-80)/365)+12.203fig,ax=plt.subplots()ax.plot(day,hours,color="orange")ax.set_xlabel("day")ax.set_ylabel("daylight hours")ax.set_title("London")plt.show()
Note that we've includedplt.show() here. This is needed to show the plot windowwhen running from a command line or in a Python script. If you run a Jupyter notebook,this command is automatically executed at the end of each cell.
For the rest of the tutorial, we'll assume that we are in a notebook and leave thisout for brevity. Depending on your context you may still need it.
If you instead want to save to a file, usefig.savefig("daylight.png").
Collect Axes properties into a singleset() call#
The properties of Matplotlib Artists can be modified through their respectiveset_*() methods. Artists additionally have a genericset() method, that takeskeyword arguments and is equivalent to calling all the respectiveset_*() methods.
ax.set_xlabel("day")ax.set_ylabel("daylight hours")
can also be written as
ax.set(xlabel="day",ylabel="daylight hours")
This is the most simple and effective reduction you can do. With that we can shortenthe above plot to
This works as long as you only need to pass one parameter to theset_*() function.The individual functions are still necessary if you want more control, e.g.set_title("London",fontsize=16).
Not storing a reference to the figure#
Another nuisance offig,ax=plt.subplots() is that you always create afigvariable, even if you don't use it. A slightly shorter version would be using thestandard variable for unused value in Python (_):_,ax=plt.subplots().However, that's only marginally better.
You can work around this by separating figure and Axes creation and chaining them
ax=plt.figure().add_subplot()
This is a bit cleaner logically and has the slight advantage that you could setfigure properties inline as well; e.g.plt.figure(facecolor="lightgoldenrod").But it has the disadvantage that it's longer thanfig,ax=plt.subplots().
You can still obtain the figure from the Axes if needed, e.g.
ax.figure.savefig("daylight_hours.png")
The example code now looks like this:
Define Axes properties during axes creation#
Theset_* methods as well asset modify existing objects. You canalternatively define them right at creation. Since you typically don't instantiateclasses yourself in Matplotlib, but rather call some factory function that createsthe object and wires it up correctly with the plot, this may seem less obvious. Butin fact you just pass the desired properties to the factory functions. You are likelydoing this already in some places without realizing. Consider the function to createa line
ax.plot(x,y,color="orange")
This is equivalent to
line,=ax.plot(x,y)line.set_color("orange")
The same can be done with functions that create Axes.
ax=plt.figure().add_subplot(xlabel="day",ylabel="daylight hours",title="London")ax.plot(day,hours,color="orange")
Important
The Axes properties are only accepted as keyword arguments byFigure.add_subplot, which creates a single Axes.
ForFigure.subplots andpyplot.subplots, you'd have to pass the propertiesas a dict via the keyword argumentsubplot_kw. The limitation here is thatsuch parameters are given to all Axes. For example, if you need two subplots(fig,(ax1,ax2)=plt.subplots(1,2)) with different labels, you have toset them individually.
Defining Axes properties during creation is best used for single subplots or whenall subplots share the same properties.
Using implicit figure creation#
You can go even further by tapping into the pyplot logic and usepyplot.axes tocreate the axes:
Warning
When using this, you have to be aware of the implicit figure semantics of pyplot.plt.axes() will only create a new figure if no figure exists. Otherwise, itwill add the Axes to the current existing figure, which is likely not what youwant.
Not storing a reference to the Axes#
If you only need to visualize one dataset, you can append the plot commanddirectly to the Axes creation. This may be useful e.g. in notebooks,where you want to create a plot with some configuration, but as little distractingcode as possible:
Total running time of the script: (0 minutes 2.878 seconds)