Histogram

Histograms represent distributions of numerical values. Common histograms include frequency distributions, frequency density distributions, probability distributions, and probability density distributions. The following script, histogram.py, illustrates how to create a frequency distribution:

1 #!/usr/bin/env python3
2 import numpy as np
3 import matplotlib.pyplot as plt
4 plt.style.use('ggplot')
5 mu1, mu2, sigma = 100, 130, 15
6 x1 = mu1 + sigma*np.random.randn(10000)
7 x2 = mu2 + sigma*np.random.randn(10000)
8 fig = plt.figure()
9 ax1 = fig.add_subplot(1,1,1)
10 n, bins, patches = ax1.hist(x1, bins=50, normed=False, color='darkgreen')
11 n, bins, patches = ax1.hist(x2, bins=50, normed=False, color='orange', alpha=0.5)
12 ax1.xaxis.set_ticks_position('bottom')
13 ax1.yaxis.set_ticks_position('left')
14 plt.xlabel('Bins')
15 plt.ylabel('Number of Values in Bin')
16 fig.suptitle('Histograms', fontsize=14, fontweight='bold')
17 ax1.set_title('Two Frequency Distributions')
18 plt.savefig('histogram.png', dpi=400, bbox_inches='tight')
19 plt.show()

Lines 6 and 7 here use Python’s random-number generator to create two normally distributed variables, x1 and x2. The mean of x1 is 100 and the mean of x2 is 130, so the distributions will overlap but won’t lie on top of one another. Lines 10 and 11 create two histograms, or frequency distributions, for the variables. bins=50 means the values should be binned into 50 bins. normed=False means the histogram should display a frequency distribution instead of a probability density. The first histogram is dark green, and the second one is orange. alpha=0.5 means the second histogram should be more transparent so we can see the dark green bars where the two histograms overlap.

Line 16 adds a centered title to the figure, sets the font size to 14, and bolds the font. Line 17 adds a centered title to the subplot, beneath the figure’s title. We use these two lines to create a title and subtitle for the plot. Figure 6-2.

Figure 6-2. A figure with two histograms created with matplotlib

Line Plot

Line plots represent numerical values along a number line. It’s common to use line plots to show data over time. The following script, line_plot.py, illustrates how to create a line plot:

1 #!/usr/bin/env python3
2 from numpy.random import randn
3 import matplotlib.pyplot as plt
4 plt.style.use('ggplot')
5 plot_data1 = randn(50).cumsum()
6 plot_data2 = randn(50).cumsum()
7 plot_data3 = randn(50).cumsum()
8 plot_data4 = randn(50).cumsum()
9 fig = plt.figure()
10 ax1 = fig.add_subplot(1,1,1)
11 ax1.plot(plot_data1, marker=r'o', color=u'blue', linestyle='-',\
12 label='Blue Solid')
13 ax1.plot(plot_data2, marker=r'+', color=u'red', linestyle='--',\
14 label='Red Dashed')
15 ax1.plot(plot_data3, marker=r'*', color=u'green', linestyle='-.',\
16 label='Green Dash Dot')
17 ax1.plot(plot_data4, marker=r's', color=u'orange', linestyle=':',\
18 label='Orange Dotted')
19 ax1.xaxis.set_ticks_position('bottom')
20 ax1.yaxis.set_ticks_position('left')
21 ax1.set_title('Line Plots: Markers, Colors, and Linestyles')
22 plt.xlabel('Draw')
23 plt.ylabel('Random Number')
24 plt.legend(loc='best')
25 plt.savefig('line_plot.png', dpi=400, bbox_inches='tight')
26 plt.show()

Again, we’re using randn to create (random) data to plot in lines 5–8. Lines 11–18 create four line plots. The lines use different types of data point markers, line colors, and line styles to illustrate some of the options. The label arguments ensure the lines are properly labeled in the legend.

Line 24 creates a legend for the plot. loc='best' instructs matplotlib to place the legend in the best location based on the open space in the plot. Alternatively, you can use this argument to specify a specific location for the legend. Figure 6-3 shows the line plots created by this script.

Figure 6-3. A figure with four line plots created with matplotlib

Scatter Plot

Scatter plots represent the values of two numerical variables along two axes—for example, height versus weight or supply versus demand. Scatter plots provide some indication of whether the variables are positively correlated (i.e., the points are concentrated in a specific configuration) or negatively correlated (i.e., the points are spread out like a diffuse cloud). You can also draw a regression line, the line that minimizes the squared error, through the points to make predictions for one variable based on values of the other variable.

The following script, scatter_plot.py, illustrates how to create a scatter plot with a regression line through the points:

1 #!/usr/bin/env python3
2 import numpy as np
3 import matplotlib.pyplot as plt
4 plt.style.use('ggplot')
5 x = np.arange(start=1., stop=15., step=1.)
6 y_linear = x + 5. * np.random.randn(14.)
7 y_quadratic = x**2 + 10. * np.random.randn(14.)
8 fn_linear = np.poly1d(np.polyfit(x, y_linear, deg=1))
9 fn_quadratic = np.poly1d(np.polyfit(x, y_quadratic, deg=2))
10 fig = plt.figure()
11 ax1 = fig.add_subplot(1,1,1)
12 ax1.plot(x, y_linear, 'bo', x, y_quadratic, 'go', \
13               x, fn_linear(x), 'b-', x, fn_quadratic(x), 'g-', linewidth=2.)
14 ax1.xaxis.set_ticks_position('bottom')
15 ax1.yaxis.set_ticks_position('left')
16 ax1.set_title('Scatter Plots Regression Lines')
17 plt.xlabel('x')
18 plt.ylabel('f(x)')
19 plt.xlim((min(x)-1., max(x)+1.))
20 plt.ylim((min(y_quadratic)-10., max(y_quadratic)+10.))
21 plt.savefig('scatter_plot.png', dpi=400, bbox_inches='tight')
22 plt.show()

We cheat a little bit here by creating data (in lines 6 and 7) that uses random numbers to deviate just a bit from a linear and a quadratic polynomial equation—and then, in lines 8 and 9, we use numpy’s polyfit and poly1d functions to create linear and quadratic polynomial equations for the line and curve through the two sets of points (x, y_linear) and (x, y_quadratic). On real-world data, you can use the polyfit function to calculate the coefficients of the polynomial of fit based on the specified degree. The poly1d function uses the coefficients to create the actual polynomial equation.

Line 12 creates the scatter plot with the two regression lines. 'bo' means the (x, y_linear) points are blue circles, and 'go' means the (x, y_quadratic) points are green circles. Similarly, 'b-' means the line through the (x, y_linear) points is a solid blue line, and 'g-' means the line through the (x, y_quadratic) points is a solid green line. You specify the width of lines with linewidth.

Play around with these display variables to see what makes a chart with the aesthetic you’re looking for!

Lines 19 and 20 set the limits of the x-axis and y-axis. The lines use the min and max functions to create the axis limits based on the actual data values. You can also use specific numbers—for example, xlim(0, 20) and ylim(0, 200). If you don’t specify axis limits, matplotlib sets the limits for you. Figure 6-4 shows the result of running this script.

Figure 6-4. A figure with two scatterplots and linear and quadratic fits created with matplotlib

Box Plot

Box plots represent data based on its minimum, first quartile, median, third quartile, and maximum values. The bottom and top of the box show the first and third quartile values, and the line through the middle of the box shows the median value. The lines, called whiskers, that extend from the ends of the box show the smallest and largest non-outlier values, and the points beyond the whiskers represent outliers.

The following script, box_plot.py, illustrates how to create a box plot:

1 #!/usr/bin/env python3
2 import numpy as np
3 import matplotlib.pyplot as plt
4 plt.style.use('ggplot')
5 N = 500
6 normal = np.random.normal(loc=0.0, scale=1.0, size=N)
7 lognormal = np.random.lognormal(mean=0.0, sigma=1.0, size=N)
8 index_value = np.random.random_integers(low=0, high=N-1, size=N)
9 normal_sample = normal[index_value]
10 lognormal_sample = lognormal[index_value]
11 box_plot_data = [normal,normal_sample,lognormal,lognormal_sample]
12 fig = plt.figure()
13 ax1 = fig.add_subplot(1,1,1)
14 box_labels = ['normal','normal_sample','lognormal','lognormal_sample']
15 ax1.boxplot(box_plot_data, notch=False, sym='.', vert=True, whis=1.5, \
16                    showmeans=True, labels=box_labels)
17 ax1.xaxis.set_ticks_position('bottom')
18 ax1.yaxis.set_ticks_position('left')
19 ax1.set_title('Box Plots: Resampling of Two Distributions')
20 ax1.set_xlabel('Distribution')
21 ax1.set_ylabel('Value')
22 plt.savefig('box_plot.png', dpi=400, bbox_inches='tight')
23 plt.show()

Line 14 creates a list named box_labels that contains labels for each of the box plots. We use this list in the boxplot function in the next line.

Line 15 uses the boxplot function to create the four box plots. notch=False means the boxes should be rectangular instead of notched in the middle. sym='.' means the flier points, the points beyond the whiskers, are dots instead of the default + symbol. vert=True means the boxes are vertical instead of horizontal. whis=1.5 specifies the reach of the whiskers beyond the first and third quartiles (e.g., Q3 + whis*IQR, IQR = interquartile range, Q3-Q1). showmeans=True specifies that the boxes should also show the mean value in addition to the median value. labels=box_labels means to use the values in box_labels to label the box plots.

Figure 6-5 shows the result of running this script.

Figure 6-5. A figure with box plots of data from normal and lognormal distributions, as well as samples of data from these two distributions, created with matplotlib