Python Data Visualization with Matplotlib — Part 1 | Rizky Maulana N | Towards Data Science

Data visualization aims to present the data into a more straightforward representation, such as scatter plot, density plot, bar chart, etc. It is also useful to give readers or analysts a global picture of their data. By visualizing your data, you can detect potential outliers. In Python, you can use various modules or libraries to visualize data. One of the mainstream modules is Matplotlib. You can visualize data using Matplotlib in various plotting styles. But, Matplotlib can not show you a dynamics plot. If you want to create a tremendous dynamic plot, you can use Dash from plotly (I hope to finish a story about a complete tutorial with Dash next month).
This story will guide you on how to visualize data with Matplotlib in a various way. 90 examples maybe can inspire you to create a plot from different points of view. It is not the most completed tutorials in data visualization with Matplotlib, but I believe that this story can accommodate many people’s needs, reach many disciples to be applied.
As I mentioned before, I will guide you through creating 90 various plot examples. The examples are distributed in 11 different style plots: scatter plot, line plot, histogram 1D, 2D, marginal plot, bar chart, box plot, violin plot, pie chart, polar chart, geographic projection, 3D plot, and contour plot. You can see Figure 1 to have a general idea of this story.
In this story, I try to focus on creating and customizing various plots. So, I assume you have known several techniques outside it, e.g., creating multiple subplots and customizing colormaps in Matplotlib. If you have not known it, I will give you some links to understand it.
At the beginning of writing this story, I plan to write only 1 story. But, I think I need to divide it into several parts because of the reading time. If I write it all in one story, it will cost more than 40 minutes. I guess you will be bored to read it all just in one story :). So, I divide it into 2 or 3 parts. I will limit the reading time to less than 30 minutes. This is the first part. Let’s start it.
To install Matplotlib, you can install it via pip with this code
pip install matplotlib
or via conda
conda install -c anaconda matplotlib
When I write this story, I installed Matplotlib version 3.3.2. You can check it by writing this code.
pip show matplotlib
If you want to check it in Jupyter Notebook (hereafter, Jupyter), you can add ! before pip, as shown in Figure 2.
If you want to upgrade your Matplotlib version, you can use the following code
pip install matplotlib --upgrade
Again, you can add ! before pip to upgrade Matplotlib via Jupyter.
If you have installed a different Matplotlib version with Matplotlib I used in this story, maybe you will face different results. Just write the issues you meet in the response columns below. I recommend you to save this story. So, you can continue your reading if you have limited time.
Before we move on the first section, I need to inform you that I have customized my Matplotlib plotting style such as using LaTeX font as default, changing the font size and family, changing xtick and ytick direction and size, and adding minor tick in the x-axis and y-axis. To use LaTeX font as your default font in Matplotlib, you can use this code
plt.rcParams['text.usetex'] = True
If you face some errors, you need to read the following story. I have explained the detailed procedures to deal with LaTeX font in Matplotlib
towardsdatascience.com
To customize the other parameters (font size, font family, and tick params) you just write this code at the beginning of your code
plt.rcParams['font.size'] = 15plt.rcParams['font.family'] = "serif"tdir = 'in'major = 5.0minor = 3.0plt.rcParams['xtick.direction'] = tdirplt.rcParams['ytick.direction'] = tdirplt.rcParams['xtick.major.size'] = majorplt.rcParams['xtick.minor.size'] = minorplt.rcParams['ytick.major.size'] = majorplt.rcParams['ytick.minor.size'] = minor
If you need to understand it in more detail, you can visit this story
towardsdatascience.com
In this section, there are eight examples of scatter plots. Before creating a scatter plot, I need to generate mock data using this code
import numpy as npimport matplotlib.pyplot as pltN = 50x = np.linspace(0., 10., N)y = np.sin(x)**2 + np.cos(x)
Variable x is an array of 50 data, from 0 to 10. Variable y is the summation of the square of sin(x) and cos(x). I want to visualize variable x in the x-axis, and variable y in the y-axis in the form of a scatter plot using this code
plt.figure()plt.scatter(x, y)
It is so simple. The code will show you a result, as shown in Figure 3.
To make it more beautiful, you can reduce the size of each data and give the label using this code
plt.scatter(x, y, s = 15, label = r'$y  = sin^2(x) + cos(x)$')
To change the color, you need to add this argument in scatter syntax
color = 'r' # r means red
If you want to make the axis scale is at the same scale, you can use this code
plt.axis('equal')
To create an axis label for the x- and y-axis, you can add the following code
plt.xlabel(r'$x$ (rad)')plt.ylabel(r'$y$')
You have labeled your scatter plot, but you have not shown it as a legend. To show it, you can use this code
plt.legend()
To save your plot, you can use save figure syntax as shown in the following code
plt.savefig('scatter2.png', dpi = 300, bbox_inches = 'tight', facecolor='w')
The code above will save your plot with the name of scatter2.png, resolution of 300 dots per inch, tight bbox, and white background. It is okay if you omitted bbox_inches and face color arguments, but maybe you will get a different result. Just try it.
Here is the full code
The code will create a scatter plot, as shown in Figure 4.
You can see that the tick direction in the x-axis and y-axis inside the axes, and the font used is in LaTeX format. If you want to change the figure size, you can add figure size arguments inside plt.figure()
plt.figure(figsize=(7, 4.5))
Change marker style
To change the marker style, for example, I want to change from dot to cross, you can add this argument in plt.scatter
marker = 'x'
Figure 5 is the result if you apply the code above
There are tons of marker styles you can use in Matplotlib. You can check it at the following link.
matplotlib.org
If you have read the documentation above, you can realize that you can use the alphabet as your marker style. I will show you the example of applying the alphabet as a marker, as shown in Figure 6.
To generate Figure 6, I create a different function for the parameter in the x- and y-axis. Here is the code to generate it
np.random.seed(100)N = 50randx = np.random.random(N) * 100randy = np.random.random(N) * 100
To visualize variable randx and randy, I run this code
plt.figure(figsize=(7, 6))plt.scatter(randx, randy, marker=r'$\beta$', s = 150, color = 'darkorange')plt.axis('equal')plt.xlabel('randx')plt.ylabel('randy')plt.tight_layout()
I use the Greek symbol beta as my marker style. You can change it with a different alphabet, such as a, B, C, d, or 1, 2, 3, etc.
Customizing the size for each data
This subsection will show you how to create a scatter plot with different sizes for each data, as shown in Figure 7.
To create it, I generate a random position for variable randx and randy, from 0 to 100 using this code
np.random.seed(100)N = 30randx = np.random.random(N) * 100randy = np.random.random(N) * 100
For your reminder, I generate random data using Numpy. In generating a random number, Numpy only generates it in a range of 0 to 1. As I know, it is a convention in generating a random number (not only in Numpy), just from 0 to 1. To modify it, you can multiply it by 100. So, you will get a random number in the range of 0 to 100.
After that, I generate a random integer size for each data from 50 to 200, using this code
size = np.random.randint(50, 200, size=N)
To visualize it, you just add the argument of the size that will be applied in each data, using this code
plt.scatter(randx, randy, s = size, color = 'darkorange')
The additional syntax in creating Figure 7 is inserting the minor tick in the x- and y-axis. To insert it, you need to import submodule MultipleLocator using this code
from matplotlib.ticker import MultipleLocator
After that, you can add this syntax to insert minor axis
ax = plt.gca()ax.xaxis.set_minor_locator(MultipleLocator(10))ax.yaxis.set_minor_locator(MultipleLocator(10))
Here is the full code to generate Figure 7.
Color-coded scatter plot
You can change the color using colormaps. It means that data with different sizes will be color-coded by a different color. You can add color arguments in plt.scatter() like this
c = size
To embed the colorbar, you can use this code
plt.colorbar()
You will get a plot, as shown in Figure 8.
Here is the full code to generate Figure 8.
Customizing the colormaps
You can change the colormaps using this argument
cmap = 'inferno'
You can check this link to understand all of the colormaps provided by Matplotlib
matplotlib.org
In this tutorial, I have created my own colormaps by combining colormaps Blues and Oranges, as shown in Figure 9.
To combine it, I use this code
from matplotlib import cmfrom matplotlib.colors import ListedColormap, LinearSegmentedColormaptop = cm.get_cmap('Oranges_r', 128)bottom = cm.get_cmap('Blues', 128)newcolors = np.vstack((top(np.linspace(0, 1, 128)),                       bottom(np.linspace(0, 1, 128))))orange_blue = ListedColormap(newcolors, name='OrangeBlue')
I create my own colormaps named orange_blue. To understand how to create and customize your own colormaps in Matplotlib, you can read it in the following link
towardsdatascience.com
To apply it, I just change color arguments c = orange_blue. You can check the result in Figure 11.
Here is the full code to generate Figure 11.
This the end of this section, creating a scatter plot with Matplotlib. If you face some errors, you can leave a comment in the response columns.
To make a line plot in Matplotlib, I will generate mock data using this code
N = 50x = np.linspace(0., 10., N)y = np.sin(x)**2 + np.cos(x)
To visualize variable x and y in the form of a line plot, you need to use the following simple code
plt.plot(x, y)
The code above will generate a figure, as shown in Figure 12.
Customizing line styles
You can change the line style of the line plot in Matplotlib using this argument
linestyle = '-'
The argument above should be inserted in plt.plot() syntax. In this tutorial, I will show you four different line style; they are
['-', '--', '-.', ':']
To generate it automatically, I use looping to make it simple. Here is the full code
I will distribute the 4 different line styles in one figure. It means that I need to create 4 axes in a figure. In Matplotlib, you can generate it by customizing subplots using GridSpec(), subplot(), and add_subplot(). In this session, I use GridSpec() syntax. I create 4 axes (2 rows and 2 columns) with width and height space equals 0.25 (see lines 6 to 12). As I mentioned at the beginning, I will only focus on customizing plots. If you need more explanation in customizing subplots in Matplotlib, you can visit this link
towardsdatascience.com
If you run the code above, it will create a figure, as shown in Figure 13.
The code will simply generate 4 different line styles, with labels and annotations for each line style. Matplotlib provides many line styles you can use. You can choose your favorite line styles via this link
matplotlib.org
Customizing line width
To customize the line width for your line plot, you can use this argument
lw = 2.0
I present you with 4 different line width, as shown in Figure 14.
I use a similar technique to create Figure 14. Here is the full code.
Creating mark every
This subsection will guide you to create a mark every feature. To understand it, I will show the result first, as shown in Figure 15.
In Figure 15, I create a circle mark for every 5 data. You can create it with this argument
'o'            # shape for each 5 datamarkevery = 5  # mark every ms = 7         # size of the circle in mark every
Here is the full code
You need to place the argument ‘o’ in the third position.
Changing the line color
To change the line color, you can apply a similar concept to change the scatter color, as shown in the following code
color = 'royalblue'
I want to show you how to generate 4 different colors and 4 different marks using looping, as shown in Figure 16.
You can reproduce Figure 16 with this code
4 different colors I used are colorblind-friendly. I get it from this link. To understand how to create colorblind-friendly palettes using that link, you read this story.
Inserting error in line plot
To demonstrate an error bar in line plot, I need to generate the error, using this code
np.random.seed(100)noise_x = np.random.random(N) * .2 + .1noise_y = np.random.random(N) * .7 + .4
The code will generate random numbers from 0.1 to 0.3 for noise_x and from 0.3 to 0.7 for noise_y. To insert the error bar for the y-axis, you can use this code
plt.errorbar(x, y, yerr = noise_y)
Figure 17 is an example of error bar in line plot.
You can create Figure 17 with this code.
To insert error bar in the x-axis, you can use this argument
xerr = noise_x
You can see the example of inserting an error bar in the x- and y-axis in Figure 18.
You can use this code to reproduce Figure 18.
If you want to visualize your data without a line plot, only the error bar, you can use this argument
fmt = 'o'    # shape of the data pointcolor = 'r'  # color of the data pointecolor ='k'   # color of the error bar
Here is the full code
The code above will show a plot, as shown in Figure 19.
Filling the error area
To visualize the error, you can also use this code
plt.fill_between(x, y + noise, y - noise, alpha = .5)
The fill_between arguments are data for the x-axis, upper limit, and lower limit for the filled area. In the code above, it is represented by y + noise and y-noise. You need to lower the transparency of the filled area. Here is the full code
If you run the code above, you will get a result, as shown in Figure 20.
Inserting the vertical and horizontal lines
You can insert a horizontal and a vertical line with this code
plt.hlines(0, xmin = 0, xmax = 10)plt.vlines(2, ymin = -3, ymax = 3)
You need to define horizontal lines in the first argument, followed by the horizontal line’s starting point and ending point. For the vertical line, it has similar arguments.
Figure 21 is an example of inserting a horizontal and vertical line.
To generate Figure 21, you can use this code
In Figure 21, the legend is placed outside the axes. You can realize it in line 17.
Filling between two vertical lines
This subsection will guide you to make a filled area between two vertical lines, as shown in Figure 22.
To reproduce Figure 22, you can use this code
You need to know the important thing in creating a filled area in Matplotlib, you need to set a suitable y-axis limit.
This section will explain how to make a histogram in 1D and 2D. I will tell you about the 1D histogram first. Before visualizing a 1D histogram, I will make a mock data, a Normal distributed random number, using this code.
N = 1000np.random.seed(10021)x = np.random.randn(N) * 2 + 15
In default, Numpy will generate a normal distributed random number with mean/median (mu) equals 0 and variance (sigma) equals 1. In the code above, I change mu to 15 and sigma to 2. To visualize variable x in 1D histogram, you can use this code
plt.hist(x)
The code will show a figure, as shown in Figure 23.
Matplotlib will generate 10 bins for a 1D histogram as the default setting. If you want to change the bins number, you can use this argument.
bins = 40
The argument will generate a 1D histogram with 40 bins, as shown in Figure 24.
Here is the full code to create Figure 24.
N = 1000np.random.seed(10021)x = np.random.randn(N) * 2 + 15plt.figure(figsize=(9, 6))plt.hist(x, bins = 40, label = r'$\mu = 15, \sigma = 2$')plt.legend()
You can also limit the range of histogram using this argument
range = (12, 18)
The argument will let histogram only shows the data from 12 to 18, as shown in Figure 25.
You can reproduce Figure 25 with this code.
I also change the histogram color using a color argument.
Horizontal histogram
You can create a horizontal histogram, as shown in Figure 26.
You need to use this argument to create a horizontal histogram
orientation = 'horizontal'
To create Figure 25, you can run this code.
If you want to show the border from each histogram, you can use this argument.
edgecolor = 'k'
I want to make the histogram border in black color, as shown in Figure 26.
To generate Figure 26, you can use this full code.
Overlapping histogram
You can show many histograms in a single figure, as shown in Figure 27.
In Figure 27, I generate three normal distributions, with different mu and sigma. You can reproduce Figure 27 with this code.
You can make it prettier by changing the histograms’ transparency, as shown in Figure 28.
If you need the full code to create Figure 28, you can read the code below. The difference with the previous code is just in the alpha argument.
You can also generate Figure 28 using a looping, as shown in this code
N = 1000mu1 = 5mu2 = 10mu3 = 15sigma1 = 5sigma2 = 3sigma3 = 2x1 = np.random.randn(N) * sigma1 + mu1x2 = np.random.randn(N) * sigma2 + mu2x3 = np.random.randn(N) * sigma3 + mu3mu = np.array([mu1, mu2, mu3])sigma = np.array([sigma1, sigma2, sigma3])x = np.array([x1, x2, x3])colors = ['royalblue', 'tomato', 'gray']plt.figure(figsize=(9, 6))for i in range(len(x)):    plt.hist(x[i], bins = 30, color = colors[i],              label = r'$\mu = $ ' + str(mu[i]) +              ', $\sigma = $ ' + str(sigma[i]), alpha = .7)plt.legend()
After see the code above, maybe you have an imagination to create a lot of histogram (more than 3) in a single figure. I will accommodate it :D. Here is the code to create and visualize 10 histograms in a single figure cleanly.
If you run the code above, you will get a result, as shown in Figure 29.
You can generate many colors merely using this link. After generating the palettes, just copy and paste it into your code. The detailed procedure of generating the palettes is provided here.
2D histogram
You can generate a 2D histogram with Matplotlib, as shown in Figure 30.
To create Figure 30, I need to generate 2 normal distribution with this code.
N = 1_000np.random.seed(100)x = np.random.randn(N)y = np.random.randn(N)
To visualize variable x and y in the 2D histogram, you can use this code.
plt.hist2d(x, y)
As in the 1D histogram, Matplotlib will generate 10 bins as the default setting for the 2D histogram. To change it, you can apply the same argument as in the 1D histogram, as shown in the code below.
bins = (25, 25)
You can see the modified bins number of the 2D histogram in Figure 31.
You also can change the colormaps of your 2D histogram using this argument
cmap = orange_blue
I want to change the colormaps from Viridis (default colormaps from Matplotlib) to my own colormaps named orange_blue. I have explained how to create your own colormaps in the previous section, or you can read it here.
Here is the full code for modifying the colormaps used in the 2D histogram.
If you run the code above, it will create a figure, as shown in Figure 32.
You can limit the range of counts for each (change the limit of the colorbar) by applying this argument into plt.hist2d().
cmin = 5, cmax = 25
Here is the full code
N = 10_000np.random.seed(100)x = np.random.randn(N)y = np.random.randn(N)plt.figure(figsize=(8.5, 7))plt.hist2d(x, y, bins=(75, 75), cmap = 'jet', cmin = 5, cmax = 25)cb = plt.colorbar()cb.set_label('counts each bin', labelpad = 10)
I use ‘jet’ colormaps with the lower limit for the colorbar equlas 5 and for the upper limit is 25. The code will generate a figure, as shown in Figure 33.
I try to change the generated random number counts from 10000 to 100000 using this code.
N = 100_000np.random.seed(100)x = np.random.randn(N)y = np.random.randn(N)plt.figure(figsize=(8.5, 7))plt.hist2d(x, y, bins=(75, 75), cmap = 'Spectral')cb = plt.colorbar()cb.set_label('counts each bin', labelpad = 10)
The code will show a result, as shown in Figure 34.
Figure 34 peaked at around 0 and distributed around -1 to 1 because I did not change the value of mu and sigma.
Marginal plot
This subsection will tell how to create a marginal distribution, as shown in Figure 35.
Figure 35 is built by scatter plot and 2 histogram. To create it, you need to understand how to customize the subplots or axes in a single figure. Figure 35 is constructed by 25 axes (5 columns and 5 rows). The detailed is shown in Figure 36. You can create Figure 36 with this code. You need to read this link to understand it.
rows = 5columns = 5grid = plt.GridSpec(rows, columns, wspace = .4, hspace = .4)plt.figure(figsize=(10, 10))for i in range(rows * columns):    plt.subplot(grid[i])       plt.annotate('grid '+ str(i), xy = (.5, .5), ha = 'center',                  va = 'center')for i in range(rows):    exec (f"plt.subplot(grid[{i}, 0])")    plt.ylabel('rows ' + str(i), labelpad = 15)for i in range(columns):    exec (f"plt.subplot(grid[-1, {i}])")    plt.xlabel('column ' + str(i), labelpad = 15)
Figure 35 shows the transformation of Figure 36. I merge some grids in Figure 36 to only 3 bigger grids. The first grid combines grids 0 to grids 3 (rows 1, column 0 to column 3). I will fill the first grid with the histogram plot. The second grid merges 16 grids from rows 1 to rows 4 and from column 0 to column 3. The last grid is built by combining grids 9, 14, 19, and 24 (rows 1, 2, 3, 4, and column 4).
To create the first grid, you can use this code.
rows = 5columns = 5grid = plt.GridSpec(rows, columns, wspace = .4, hspace = .4)plt.figure(figsize=(10, 10))plt.subplot(grid[0, 0:-1])
After that, add the code below to insert 1D histogram
plt.hist(x, bins = 30, color = 'royalblue', alpha = .7)
To create the second grid, you can add this code to the code above
plt.subplot(grid[1:rows+1, 0:-1])
Add this code to generate scatter plot in the second grid.
plt.scatter(x, y, color = 'royalblue', s = 10)plt.axis('equal')
Here is the code to generate the third grid and its histogram. You need to insert the code below into the first grid code
plt.subplot(grid[1:rows+1, -1])plt.hist(y, bins = 30, orientation='horizontal',          color = 'royalblue', alpha = .7)
You can combine it all, as shown in the following code.
Next, I will change the scatter plot in the second grid with the 2D histogram, as shown in Figure 37.
You can reproduce Figure 37 with this code.
Please leave some comments in the response column if you meet some errors.
If you want to visualize your data with a bar chart, this is suitable for you. Before I create a bar chart in Matplotlib, as usual, I want to create the mock data to be shown. I want to create data in the Math exam score for six persons. To create it, I use the following code.
name = ['Adam', 'Barry', 'Corbin', 'Doe', 'Evans', 'Frans']np.random.seed(100)N = len(name)math = np.random.randint(60, 100, N)
I generate the Math exam scores from 60 to 100. To visualize it, you can use this code.
plt.bar(name, math, alpha = .7)
After adding some information, I generate a bar chart, as shown in Figure 38.
Here is the full code to generate Figure 38.
name = ['Adam', 'Barry', 'Corbin', 'Doe', 'Evans', 'Frans']np.random.seed(100)N = len(name)math = np.random.randint(60, 100, N)plt.figure(figsize=(9, 6))plt.bar(name, math, alpha = .7)plt.ylabel('Math Exam')
After that, I create some more mock data for Physics, Biology, and Chemistry exam scores using this code.
np.random.seed(100)N = len(name)math = np.random.randint(60, 100, N)physics = np.random.randint(60, 100, N)biology = np.random.randint(60, 100, N)chemistry = np.random.randint(60, 100, N)
You can create a table, in Python we call it DataFrame, using Pandas. The DataFrame I create from the mock data is shown in Figure 39.
As a default, I did not insert the code on how to create the DataFrame. But, if you need it, you leave your request in the response column.
Then, I visualize it, as shown in Figure 40.
To create Figure 40, you can use this code.
name = ['Adam', 'Barry', 'Corbin', 'Doe', 'Evans', 'Frans']np.random.seed(100)N = len(name)math = np.random.randint(60, 100, N)physics = np.random.randint(60, 100, N)biology = np.random.randint(60, 100, N)chemistry = np.random.randint(60, 100, N)rows = 2columns = 2plt.figure(figsize=(12, 8))grid = plt.GridSpec(rows, columns, wspace = .25, hspace = .25)plt.subplot(grid[0])plt.bar(name, math, alpha = .7)plt.ylabel('Math Exam')plt.ylim(60, 100)plt.subplot(grid[1])plt.bar(name, physics, alpha = .7)plt.ylabel('Physics Exam')plt.ylim(60, 100)plt.subplot(grid[2])plt.bar(name, biology, alpha = .7)plt.ylabel('Biology Exam')plt.ylim(60, 100)plt.subplot(grid[3])plt.bar(name, chemistry, alpha = .7)plt.ylabel('Chemistry Exam')plt.ylim(60, 100)
or use this code if you want use a looping.
name = ['Adam', 'Barry', 'Corbin', 'Doe', 'Evans', 'Frans']course_name = ['Math', 'Physics', 'Biology', 'Chemistry']N = len(name)rows = 2columns = 2plt.figure(figsize=(12, 8))grid = plt.GridSpec(rows, columns, wspace = .25, hspace = .25)for i in range(len(course_name)):    np.random.seed(100)    course = np.random.randint(60, 100, N)    plt.subplot(grid[i])    plt.bar(name, course, alpha = .7)    plt.ylabel(course_name[i] + ' Exam')    plt.ylim(60, 100)
Horizontal bar chart
You can use a horizontal bar chart with this code.
plt.barh(name, course)
I want to present Figure 40 in the form of horizontal bar chart and in various colors. Here is the full code to generate it.
name = ['Adam', 'Barry', 'Corbin', 'Doe', 'Evans', 'Frans']course_name = ['Math', 'Physics', 'Biology', 'Chemistry']colors = ['#00429d', '#7f40a2', '#a653a1', '#c76a9f',           '#e4849c', '#d0e848']N = len(name)rows = 2columns = 2plt.figure(figsize=(12, 8))grid = plt.GridSpec(rows, columns, wspace = .25, hspace = .25)for i in range(len(course_name)):    np.random.seed(100)    course = np.random.randint(60, 100, N)    plt.subplot(grid[i])    plt.barh(name, course, color = colors)    plt.xlabel(course_name[i] + ' Exam')    plt.xlim(60, 100)    plt.gca().invert_yaxis()
After you run the code above, you will get a result, as shown in Figure 41.
You can insert the error bar in the horizontal bar chart using this argument
N = len(name)noise = np.random.randint(1, 3, N)plt.barh(name, course, xerr = noise)
I create the error using integer random number from 1 to 3, as mentioned in the variable noise. After adding some elements for my horizontal bar chart, I show it, as shown in Figure 42.
You can reproduce Figure 42 with this code.
name = ['Adam', 'Barry', 'Corbin', 'Doe', 'Evans', 'Frans']course_name = ['Math', 'Physics', 'Biology', 'Chemistry']N = len(name)rows = 2columns = 2plt.figure(figsize=(12, 8))grid = plt.GridSpec(rows, columns, wspace = .25, hspace = .25)np.random.seed(100)for i in range(len(course_name)):    course = np.random.randint(60, 95, N)    noise = np.random.randint(1, 3, N)    plt.subplot(grid[i])    plt.barh(name, course, color = colors, xerr = noise,              ecolor = 'k')    plt.xlabel(course_name[i] + ' Exam')    plt.xlim(60, 100)    plt.gca().invert_yaxis()
Maybe, you realize that my mock data (with error) is not realistic. You can not meet an exam score with the uncertainty. But, I think it is still a good example in understanding the bar chart in Matplotlib.
This is the end of part 1. As I mentioned before, I try to limit the reading time (less than 30 minutes), so you can enjoy the reading. This part only covers 4 from 11 sections, scatter plot, line plot, histogram, and bar chart. In the next part, I will show the tutorials to create a box plot, violin plot, pie chart, polar chart, geographic projection, 3D plot, and contour plot. If the next part is consuming more than 30 minutes, I will divide it again.
Data visualization is significant in analyzing data from small data or big data in the technological era. We need it to have a global picture of our data. Various types of visualization you can use with Matplotlib. This is just a small part of python plotting with Matplotlib.
towardsdatascience.com
towardsdatascience.com
towardsdatascience.com
towardsdatascience.com
towardsdatascience.com
That’s all. Thanks for reading this story. Comment and share if you like it. I also recommend you follow my account to get a notification when I post my new story. In a couple of days, I will publish Part 2 for Visualizations with Matplotlib.