Matplotlib 2016


In [1]:
%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 [2]:
xv=[1,2,3,4]; yv=[5,1,4,0]
plt.plot(xv,yv);


A simple plotting example. Maybe some variations:


In [3]:
plt.plot(xv,yv,'ro');



In [4]:
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 [5]:
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 [6]:
plt.setp(myplot)


  agg_filter: unknown
  alpha: float (0.0 transparent through 1.0 opaque) 
  animated: [True | False] 
  antialiased or aa: [True | False] 
  axes: an :class:`~matplotlib.axes.Axes` instance 
  clip_box: a :class:`matplotlib.transforms.Bbox` instance 
  clip_on: [True | False] 
  clip_path: [ (:class:`~matplotlib.path.Path`, :class:`~matplotlib.transforms.Transform`) | :class:`~matplotlib.patches.Patch` | None ] 
  color or c: any matplotlib color 
  contains: a callable function 
  dash_capstyle: ['butt' | 'round' | 'projecting'] 
  dash_joinstyle: ['miter' | 'round' | 'bevel'] 
  dashes: sequence of on/off ink in points 
  drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] 
  figure: a :class:`matplotlib.figure.Figure` instance 
  fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] 
  gid: an id string 
  label: string or anything printable with '%s' conversion. 
  linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]
  linewidth or lw: float value in points 
  marker: :mod:`A valid marker style <matplotlib.markers>`
  markeredgecolor or mec: any matplotlib color 
  markeredgewidth or mew: float value in points 
  markerfacecolor or mfc: any matplotlib color 
  markerfacecoloralt or mfcalt: any matplotlib color 
  markersize or ms: float 
  markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]
  path_effects: unknown
  picker: float distance in points or callable pick function ``fn(artist, event)`` 
  pickradius: float distance in points 
  rasterized: [True | False | None] 
  sketch_params: unknown
  snap: unknown
  solid_capstyle: ['butt' | 'round' |  'projecting'] 
  solid_joinstyle: ['miter' | 'round' | 'bevel'] 
  transform: a :class:`matplotlib.transforms.Transform` instance 
  url: a url string 
  visible: [True | False] 
  xdata: 1D array 
  ydata: 1D array 
  zorder: any number 

Some more commands for plot formatting:


In [7]:
plt.axis()


Out[7]:
(0.0, 1.0, 0.0, 1.0)

In [8]:
plt.axis([0.5,4.5,-0.5,5.5])


Out[8]:
[0.5, 4.5, -0.5, 5.5]

Let's switch to the Qt backend for plotting


In [9]:
%matplotlib
plt.ioff() # deactivates 'interactive' mode


Using matplotlib backend: Qt4Agg

In [10]:
fig = plt.figure()
ti=plt.title('Very important data')
xl=plt.xlabel('time'); yl=plt.ylabel('value')
plt.setp(xl,fontweight='bold');
plt.show()

Figures can be saved in a number of output formats such as Postscript:


In [11]:
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 [12]:
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 [13]:
plt.close(fig)

Or in MATLAB style, close all open figures:


In [14]:
plt.close('all')

Let's do a figure with several subpanels:


In [15]:
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 [16]:
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 [17]:
# 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 [18]:
xv=np.arange(-10,10.5,0.5); xv


Out[18]:
array([-10. ,  -9.5,  -9. ,  -8.5,  -8. ,  -7.5,  -7. ,  -6.5,  -6. ,
        -5.5,  -5. ,  -4.5,  -4. ,  -3.5,  -3. ,  -2.5,  -2. ,  -1.5,
        -1. ,  -0.5,   0. ,   0.5,   1. ,   1.5,   2. ,   2.5,   3. ,
         3.5,   4. ,   4.5,   5. ,   5.5,   6. ,   6.5,   7. ,   7.5,
         8. ,   8.5,   9. ,   9.5,  10. ])

In [19]:
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 [20]:
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 [21]:
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 [22]:
plt.semilogy(xv,np.exp(-xv/0.01)+0.5*np.exp(-xv/10)+0.2*np.exp(-xv/200))


Out[22]:
[<matplotlib.lines.Line2D at 0x7f19f229a7f0>]

Anybody bar charts?


In [23]:
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 [24]:
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 [25]:
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


Out[25]:
([<matplotlib.patches.Wedge at 0x7f19f21192b0>,
  <matplotlib.patches.Wedge at 0x7f19f21e7e48>,
  <matplotlib.patches.Wedge at 0x7f19f20f1780>,
  <matplotlib.patches.Wedge at 0x7f19f20f62e8>],
 [<matplotlib.text.Text at 0x7f19f216f9b0>,
  <matplotlib.text.Text at 0x7f19f20f1f98>,
  <matplotlib.text.Text at 0x7f19f20f62b0>,
  <matplotlib.text.Text at 0x7f19f21a37f0>])

As you will have seen, we retrieved handles to the individual pie slices. Let's do something with them:


In [26]:
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 [27]:
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 [28]:
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 [29]:
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 distint representation is provided by pcolormesh().


In [30]:
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 [31]:
from mpl_toolkits.mplot3d import Axes3D

Let's switch to the Qt backend for 3D plotting


In [32]:
%matplotlib
plt.ioff()


Using matplotlib backend: Qt4Agg

Then, we can play around.


In [33]:
plt.close('all'); fig=plt.figure()
ax=Axes3D(fig)
plt.show()

Try moving and rotating the (so far empty) plot in three dimensions. Once you have calmed down, let's populate the plot with some data:


In [34]:
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 [35]:
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 [36]:
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 [37]:
plt.close('all'); fig=plt.figure()
ax=Axes3D(fig)
ax.contour(cx,cy,cz,cstride=2,rstride=2, cmap=plt.cm.jet)
plt.show()

Style sheets


In [38]:
%matplotlib inline
plt.close('all')

There are several predefinded style sheets for matplotlib. You can show all availible styles by typing


In [39]:
plt.style.available


Out[39]:
['fivethirtyeight',
 'seaborn-white',
 'seaborn-darkgrid',
 'dark_background',
 'classic',
 'grayscale',
 'seaborn-colorblind',
 'ggplot',
 'seaborn-whitegrid',
 'seaborn-muted',
 'seaborn-dark-palette',
 'seaborn-poster',
 'seaborn-notebook',
 'seaborn-ticks',
 'seaborn-deep',
 'bmh',
 'seaborn-dark',
 'seaborn-paper',
 'seaborn-bright',
 'seaborn-pastel',
 'seaborn-talk']

to pick one of them, type e.g.


In [40]:
plt.style.use('ggplot')

and your plots will look similar to those created with ggplot2 in R


In [41]:
x = np.linspace(0,10,100)
y = np.sin(x)
plt.plot(x,y)


Out[41]:
[<matplotlib.lines.Line2D at 0x7f19f2a30128>]

Exercises for Numpy and Matplotlib

Exercise 1

Plot the following functions into individual subplots:

$f(x) = e^{-\alpha x^2},\quad g(x) = \alpha x^3-5x^2, \quad h(x) = \mathrm{erf}(x)$

with $\alpha \in \{0.1,0.5,1\}$

hint: use scipy for the definition of $\mathrm{erf}(x)$


In [42]:
%matplotlib inline

Exercise 2

generate two 1D-arrays $A$ and $B$ of size $N$ containing Gaussian random numbers


In [43]:
N = 1e4

Check whether they are correlated using a scatter plot


In [44]:
%matplotlib inline

Plot their 2D density as a contour plot (hint: the density can be obtained from a histogram)


In [ ]:

Plot the density as 3D surface plot


In [45]:
%matplotlib
plt.ioff()


Using matplotlib backend: Qt4Agg

In [ ]: