In [ ]:
%matplotlib inline
from matplotlib import pyplot as plt
import numpy as np
Above commands enable pylab environment => direct access to numpy, scipy and matplotlib. The option 'inline' results in plot outputs to be directly embedded in the Notebook. If this causes problems, remove the option 'inline'.
In [ ]:
xv=[1,2,3,4]; yv=[5,1,4,0]
plt.plot(xv,yv);
A simple plotting example. Maybe some variations:
In [ ]:
plt.plot(xv,yv,'ro');
In [ ]:
myplot=plt.plot(xv,yv,'k--');
plt.setp(myplot,linewidth=3.0,marker='+',markersize=30);
Alternatively, Matplotlib understands the MATLAB syntax, e.g., for the above command (does not work with 'inline' enabled):
In [ ]:
myplot=plt.plot(xv,yv,'k--');
plt.setp(myplot,'linewidth',3.0,'marker','+','markersize',30);
Available settings for a plot can be found this way (does not work with 'inline' enabled):
In [ ]:
plt.setp(myplot)
Some more commands for plot formatting:
In [ ]:
plt.axis()
In [ ]:
plt.axis([0.5,4.5,-0.5,5.5])
Let's switch to the Qt backend for plotting
In [ ]:
%matplotlib
plt.ioff() # deactivates 'interactive' mode
In [ ]:
fig = plt.figure()
ti=plt.title('Very important data')
xl=plt.xlabel('time'); yl=plt.ylabel('value')
plt.setp(xl,fontweight='bold');
plt.plot(xv,yv,'k--')
plt.show()
Figures can be saved in a number of output formats such as Postscript:
In [ ]:
fig.savefig('foo.ps', dpi=600, format='ps',orientation='landscape')
Alternatively, you can also save figures in PNG bitmap and PDF vector formats. (Note that some export formats may not be supported on your platform.)
In [ ]:
fig.savefig('foo.png', dpi=600, format='png',orientation='landscape')
fig.savefig('foo.pdf', dpi=600, format='pdf',orientation='landscape')
You can close an open figure using its handle:
In [ ]:
plt.close(fig)
Or in MATLAB style, close all open figures:
In [ ]:
plt.close('all')
Let's do a figure with several subpanels:
In [ ]:
fig = plt.figure()
plt.subplot(2,1,1)
plt.plot(xv,yv,'b-')
plt.subplot(2,1,2)
plt.plot(yv,xv,'ro')
plt.show()
In [ ]:
plt.close(fig)
Especially for figures with multiple subpanels it may be advisable to increase the figure size somewhat. Do this by using function arguments in the figure() call:
In [ ]:
# switch back to inline mode
%matplotlib inline
fig2=plt.figure(figsize=(10,10))
plt.subplot(2,1,1)
plt.plot(xv,yv,'b-')
plt.subplot(2,1,2)
plt.plot(yv,xv,'ro');
By using Numpy arrays, Matplotlib can conveniently be used as a function ploting program:
In [ ]:
xv=np.arange(-10,10.5,0.5); xv
In [ ]:
plt.plot(xv,2*xv**3-5*xv**2+7*xv)
plt.plot(xv,2000*np.cos(xv),'r--')
plt.text(-10,-2800,'curve A')
plt.text(3,1500,'curve B');
Certainly, you can do plots with logarithmic scale:
In [ ]:
xv_lin=np.arange(-3,3.01,0.02)
xv=10.**xv_lin
plt.semilogx(xv,np.exp(-xv/0.01)+0.5*np.exp(-xv/10)+0.2*np.exp(-xv/200));
Let's add grid lines:
In [ ]:
plt.semilogx(xv,np.exp(-xv/0.01)+0.5*np.exp(-xv/10)+0.2*np.exp(-xv/200))
plt.grid(color='k')
Analogously, you can use semilogy() and loglog() for plots with log y-axis and loglog plots.
In [ ]:
plt.semilogy(xv,np.exp(-xv/0.01)+0.5*np.exp(-xv/10)+0.2*np.exp(-xv/200))
Anybody bar charts?
In [ ]:
xv=[0.5,1.5,2.5,3.5]; yv=[2,5,1,6]
mybar=plt.bar(xv, yv, width=1, yerr=0.5, facecolor='b')
Let's pimp the plot a little:
In [ ]:
mybar=plt.bar(xv, yv, width=1, yerr=0.5);
plt.xticks(xv, ['A','B','C','D'])
plt.setp(mybar, facecolor='r', edgecolor='w');
For horizontal bar charts, you would use barh().
Where there are bars, there should be pies:
In [ ]:
plt.figure(figsize=(5,5))
handles=plt.pie([1,2,3,4], explode=[0.2,0,0,0], shadow=True, labels=['A','B','C','D']);
handles
As you will have seen, we retrieved handles to the individual pie slices. Let's do something with them:
In [ ]:
plt.figure(figsize=(5,5))
handles=plt.pie([1,2,3,4], explode=[0.2,0,0,0], shadow=True, labels=['A','B','C','D'])
plt.setp(handles[0] [0], color='y')
plt.setp(handles[1] [0], text='Blubber');
Matplotlib also offers quiver() plots which are illustrated in the following example (taken from http://www.loria.fr/~rougier/teaching/matplotlib/):
In [ ]:
n=8; X,Y=np.mgrid[0:n,0:n]
T=np.arctan2(Y-n/2.0,X-n/2.0)
R=10+np.sqrt((Y-n/2.0)**2+(X-n/2.0)**2)
U,V=R*np.cos(T),R*np.sin(T)
plt.axes([0.025,0.025,0.95,0.95])
plt.quiver(X,Y,U,V,R,alpha=.5)
plt.quiver(X,Y,U,V, edgecolor='k', facecolor= 'None', linewidth=.5);
Polar plots are also nicely illustrated on the very same homepage:
In [ ]:
ax=plt.axes([0.025,0.025,0.95,0.95],polar=True)
N=20; theta=np.arange(0.0,2*np.pi,2*np.pi/N)
radii=10*np.random.rand(N)
width=np.pi/4*np.random.rand(N)
bars=plt.bar(theta,radii,width=width,bottom=0.0)
for r,bar in zip(radii,bars):
bar.set_facecolor( plt.cm.jet(r/10.))
bar.set_alpha(0.5)
Contour plots are well suited for visualization of three-dimensional data sets:
In [ ]:
xv=np.linspace(-10,10,100); yv=xv
X,Y=np.meshgrid(xv,yv)
Z=np.exp(-((X-1)**2/2/0.5**2)-((Y+2)**2/2/3**2))
Z=Z+1.5*np.exp(-((X-5)**2/2/4**2)-((Y-6)**2/2/3**2))
plt.contourf(X,Y,Z,10,alpha=0.5,cmap=plt.cm.hot)
C=plt.contour(X,Y,Z,10,colors='black', linewidth=0.5)
plt.clabel(C,inline=1,fontsize=10);
A similar yet distinct representation is provided by pcolormesh().
In [ ]:
plt.pcolormesh(X,Y,Z,alpha=0.5,cmap=plt.cm.hot)
plt.axis([-5,10,-8,10]);
Compare the two figures, spot the similarities and differences.
Matplotlib sports an add-on module for 3D graphics as detailed below. First, we need to import this module.
In [ ]:
from mpl_toolkits.mplot3d import Axes3D
Let's switch to the Qt backend for 3D plotting
In [ ]:
%matplotlib
plt.ioff()
Then, we can play around.
In [ ]:
plt.close('all'); fig=plt.figure()
ax=Axes3D(fig)
plt.show()
Try moving and rotating the (so far empty) plot in three dimensions. After the first excitement has settled, let's populate the plot with some data:
In [ ]:
plt.close('all'); fig=plt.figure()
ax=Axes3D(fig)
import random as rn
xv=[]; yv=[]; zv=[]
for c in range(100):
xv.append(rn.random()); yv.append(rn.random())
zv.append(rn.random())
ax.scatter(xv,yv,zv)
plt.show()
In addition to the above 3D scatter plot, other plot types are supported, such as 3D surface plots:
In [ ]:
plt.close('all'); fig=plt.figure()
ax=Axes3D(fig)
xv=np.linspace(-10,10,100); yv=np.linspace(-10,10,100)
cx,cy=np.meshgrid(xv,yv)
cz=0.5*cx+np.exp(-cy**2)
tilt=ax.plot_surface(cx,cy,cz,linewidth=0, cmap=plt.cm.jet);
plt.show()
Try some other colormaps such as cm.bone, cm.spring or cm.cool (once more, these are the MATLAB color schemes).
We do one more example that shows the use of 3D surface and 3D contour plots (as opposed to the 2D contour plots above).
In [ ]:
plt.close('all'); fig=plt.figure()
ax=Axes3D(fig)
xv=np.linspace(-10,10,100); yv=np.linspace(-10,10,100)
cx,cy=np.meshgrid(xv,yv)
cz=0*cx
def gauss2D(x0,y0,sigx=1,sigy=1,height=1):
z=height*np.exp(-((cx-x0)**2/2/sigx**2)-((cy-y0)**2/2/sigy**2))
return z
cz=cz+gauss2D(-2,3)
cz=cz+gauss2D(2,4,2,3)
ax.plot_surface(cx,cy,cz,linewidth=0,cstride=2, rstride=2,cmap=plt.cm.jet)
plt.show()
Let's display the same data in contour representation:
In [ ]:
plt.close('all'); fig=plt.figure()
ax=Axes3D(fig)
ax.contour(cx,cy,cz,cstride=2,rstride=2, cmap=plt.cm.jet)
plt.show()
In [ ]:
%matplotlib inline
plt.close('all')
There are several predefinded style sheets for matplotlib. You can show all availible styles by typing
In [ ]:
plt.style.available
to pick one of them, type e.g.
In [ ]:
plt.style.use('ggplot')
and your plots will look similar to those created with ggplot2 in R
In [ ]:
x = np.linspace(0,10,100)
y = np.sin(x)
plt.plot(x,y)