Data visualization is concerned with the presentation of data in a pictorial or graphical form. It is one of the most important tasks in data analysis, since it enables us to see analytical results, detect outliers, and make decisions for model building. There are many Python libraries for visualization, of which matplotlib, seaborn, bokeh, and ggplot are among the most popular. However, in this chapter, we mainly focus on the matplotlib library that is used by many people in many different contexts.
Matplotlib produces publication-quality figures in a variety of formats, and interactive environments across Python platforms. Another advantage is that pandas comes equipped with useful wrappers around several matplotlib plotting routines, allowing for quick and handy plotting of Series and DataFrame objects.
The IPython package started as an alternative to the standard interactive Python shell, but has since evolved into an indispensable tool for data exploration, visualization, and rapid prototyping. It is possible to use the graphical capabilities offered by matplotlib from IPython through various options, of which the simplest to get started with is the pylab flag:
$ ipython --pylab
This flag will preload matplotlib and numpy for interactive use with the default matplotlib backend. IPython can run in various environments: in a terminal, as a Qt application, or inside a browser. These options are worth exploring, since IPython has enjoyed adoption for many use cases, such as prototyping, interactive slides for more engaging conference talks or lectures, and as a tool for sharing research.
The easiest way to get started with plotting using matplotlib is often by using the MATLAB API that is supported by the package:
>>> import matplotlib.pyplot as plt >>> from numpy import * >>> x = linspace(0, 3, 6) >>> x array([0., 0.6, 1.2, 1.8, 2.4, 3.]) >>> y = power(x,2) >>> y array([0., 0.36, 1.44, 3.24, 5.76, 9.]) >>> figure() >>> plot(x, y, 'r') >>> xlabel('x') >>> ylabel('y') >>> title('Data visualization in MATLAB-like API') >>> plt.show()
The output for the preceding command is as follows:
However, star imports should not be used unless there is a good reason for doing so. In the case of matplotlib, we can use the canonical import:
>>> import matplotlib.pyplot as plt
The preceding example could then be written as follows:
>>> plt.plot(x, y) >>> plt.xlabel('x') >>> plt.ylabel('y') >>> plt.title('Data visualization using Pyplot of Matplotlib') >>> plt.show()
The output for the preceding command is as follows:
If we only provide a single argument to the plot function, it will automatically use it as the y values and generate the x values from 0 to N-1, where N is equal to the number of values:
>>> plt.plot(y) >>> plt.xlabel('x') >>> plt.ylabel('y') >>> plt.title('Plot y value without given x values') >>> plt.show()
The output for the preceding command is as follows:
By default, the range of the axes is constrained by the range of the input x and y data. If we want to specify the viewport of the axes, we can use the axis() method to set custom ranges. For example, in the previous visualization, we could increase the range of the x axis from [0, 5] to [0, 6], and that of the y axis from [0, 9] to [0, 10], by writing the following command:
>>> plt.axis([0, 6, 0, 12])
The default line format when we plot data in matplotlib is a solid blue line, which is abbreviated as b-. To change this setting, we only need to add the symbol code, which includes letters as color string and symbols as line style string, to the plot function. Let us consider a plot of several lines with different format styles:
>>> plt.plot(x*2, 'g^', x*3, 'rs', x**x, 'y-') >>> plt.axis([0, 6, 0, 30]) >>> plt.show()
The output for the preceding command is as follows:
There are many line styles and attributes, such as color, line width, and dash style, that we can choose from to control the appearance of our plots. The following example illustrates several ways to set line properties:
>>> line = plt.plot(y, color='red', linewidth=2.0) >>> line.set_linestyle('--') >>> plt.setp(line, marker='o') >>> plt.show()
The output for the preceding command is as follows:
The following table lists some common properties of the line2d plotting:
|
Property |
Value type |
Description |
|---|---|---|
|
|
Any matplotlib color |
This sets the color of the line in the figure |
|
|
On/off |
This sets the sequence of ink in the points |
|
|
|
This sets the data used for visualization |
|
|
[ |
This sets the line style in the figure |
|
|
Float value in points |
This sets the width of line in the figure |
|
|
Any symbol |
This sets the style at data points in the figure |
By default, all plotting commands apply to the current figure and axes. In some situations, we want to visualize data in multiple figures and axes to compare different plots or to use the space on a page more efficiently. There are two steps required before we can plot the data. Firstly, we have to define which figure we want to plot. Secondly, we need to figure out the position of our subplot in the figure:
>>> plt.figure('a') # define a figure, named 'a' >>> plt.subplot(221) # the first position of 4 subplots in 2x2 figure >>> plt.plot(y+y, 'r--') >>> plt.subplot(222) # the second position of 4 subplots >>> plt.plot(y*3, 'ko') >>> plt.subplot(223) # the third position of 4 subplots >>> plt.plot(y*y, 'b^') >>> plt.subplot(224) >>> plt.show()
The output for the preceding command is as follows:
In this case, we currently have the figure a. If we want to modify any subplot in figure a, we first call the command to select the figure and subplot, and then execute the function to modify the subplot. Here, for example, we change the title of the second plot of our four-plot figure:
>>> plt.figure('a') >>> plt.subplot(222) >>> plt.title('visualization of y*3') >>> plt.show()
The output for the preceding command is as follows:
There is a convenience method, plt.subplots(), to creating a figure that contains a given number of subplots. As inthe previous example, we can use the plt.subplots(2,2) command to create a 2x2 figure that consists of four subplots.
We can also create the axes manually, instead of rectangular grid, by using the plt.axes([left, bottom, width, height]) command, where all input parameters are in the fractional [0, 1] coordinates:
>>> plt.figure('b') # create another figure, named 'b' >>> ax1 = plt.axes([0.05, 0.1, 0.4, 0.32]) >>> ax2 = plt.axes([0.52, 0.1, 0.4, 0.32]) >>> ax3 = plt.axes([0.05, 0.53, 0.87, 0.44]) >>> plt.show()
The output for the preceding command is as follows:
However, when you manually create axes, it takes more time to balance coordinates and sizes between subplots to arrive at a well-proportioned figure.
