But if you’re doing data science or statistics in Python, you’ll need to create bar charts. <\/p>\n
The contents of this tutorial<\/h4>\n
To try to make bar charts easier to understand, this tutorial will explain bar charts in matplotlib, step by step.<\/p>\n
The tutorial has several different sections. Note that you can click on these links and they will take you to the appropriate section.<\/p>\n
- \n
- A quick introduction to matplotlib<\/a><\/li>\n
- The syntax for the matplotlib bar chart<\/a><\/li>\n
- Examples of how to make a bar chart with matplotlib<\/a><\/li>\n<\/ul>\n
If you need help with something specific, you can click on one of the links.<\/p>\n
However, if you’re just getting started with matplotlib, I recommend that you read the entire tutorial. Things will make more sense that way.<\/p>\n
Ok. First, let’s briefly talk about matplotlib.<\/p>\n
<\/a><\/p>\n
A quick introduction to matplotlib<\/h2>\n
If you’re new to data visualization in Python, you might not be familiar with matplotlib. <\/p>\n
Matplotlib<\/a> is a module in the Python<\/a> programming language for data visualization and plotting.<\/p>\n
For the most part, it is the most common data visualization tool in Python. If you’re doing data science or scientific computing in Python, you are very likely to see it.<\/p>\n
However, even though matplotlib is extremely common, it has a few problems.<\/p>\n
The big problem is the syntax. Matplotlib’s syntax is fairly low-level. The low-level nature of matplotlib can make it harder to accomplish simple tasks. If you’re only using matplotlib, you might need to use a lot of code to create simple charts.<\/p>\n
There’s a solution to this though.<\/p>\n
To simplify matplotlib, you can use pyplot.<\/p>\n
What is pyplot?<\/h3>\n
Pyplot is a sub-module within matplotlib. <\/p>\n
Essentially, pyplot provides a group of relatively simple functions for performing common data visualization tasks. <\/p>\n
For example, there are simple functions for creating common charts like the scatter plot<\/a>, the bar chart, the histogram, and others.<\/p>\n
If you’re new to matplotlib and pyplot, I recommend that you check out some of our related tutorials:<\/p>\n
- \n
- How to make a scatterplot with matplotlib<\/a><\/li>\n
- A quick introduction to the matplotlib histogram<\/a><\/li>\n
- How to make a line chart with matplotlib<\/a><\/li>\n<\/ul>\n
In this tutorial though, we’re going to focus on creating bar charts with pyplot and matplotlib.<\/p>\n
With that in mind, let’s examine the syntax.<\/p>\n
<\/a><\/p>\n
The syntax of the matplotlib bar chart<\/h2>\n
The syntax to create a bar chart with pyplot isn’t that bad, but it has a few “gotchas” that can confuse beginners.<\/p>\n
Let’s take a high-level look at the syntax (we’ll look at the details later).<\/p>\n
To create a bar chart with pyplot, we use the
plt.bar()<\/code> function. <\/p>\n![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2019\/02\/matplotlib-bar-chart-syntax-explanation.png\")
<\/p>\nInside of the plt.bar function are several parameters. <\/p>\n
In the picture above, I’ve shown four:
x<\/code>,height<\/code>,width<\/code>, andcolor<\/code>. The plt.bar function has more parameters than these four, but these four are the most important for creating basic bar charts, so we will focus on them.<\/p>\nLet’s talk a little more specifically about these parameters.<\/p>\n
The parameters of plt.bar<\/h3>\n
Here, I’ll explain four important parameters of the plt.bar function:
x<\/code>,height<\/code>,width<\/code>, andcolor<\/code>.<\/p>\nx<\/h5>\n
The
x<\/code> parameter specifies the position of the bars along the x axis. <\/p>\n![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2018\/12\/plt-bar-explanation-x-parameter.png\")
<\/p>\nSo if your bars are at positions 0, 1, 2, and 3 along the x axis, those are the values that you would need to pass to the
x<\/code> parameter.<\/p>\nYou need to provide these values in the form of a “sequence” of scalar values. That means that your values (e.g., 0, 1, 2, 3) will need to be contained inside of a Python sequence<\/a>, like a list or a tuple.<\/p>\n
In this tutorial, I’m assuming that you understand what a Python sequence is. If you don’t, do some preliminary reading on Python sequences first, and then come back when you understand them.<\/p>\n
height<\/h5>\n
The
height<\/code> parameter controls the height of the bars.<\/p>\n![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2019\/02\/plt-bar-explanation-height-parameter.png\")
<\/p>\nSimilar to the
x<\/code> parameter, you need to provide a sequence of values to theheight<\/code> parameter …. one value for each bar.<\/p>\nSo if there are four bars, you’ll need to pass a sequence of four values. If there are five bars, you need to provide a sequence of five values. Etc.<\/p>\n
The examples section<\/a> will show you how this works.<\/p>\n
width<\/h5>\n
The
width<\/code> parameter controls the width of the bars.<\/p>\n![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2019\/02\/plt-bar-explanation-width-parameter.png\")
<\/p>\nYou can provide a single value, in which case all of the bars will have the same width.<\/p>\n
Or, you can provide a sequence of values to manually set the width of different bars.<\/p>\n
By default, the
width<\/code> parameter is set to .8. <\/p>\ncolor<\/h5>\n
The
color<\/code> parameter controls the interior color of the bars.<\/p>\nYou can set the value to a named color (like “red”, “blue”, “green”, etc) or you can set the color to a hexidecimal color<\/a>. <\/p>\n
Although I strongly prefer hex colors (because they give you a lot of control over the aesthetics of your visualizations), hex colors are a little more complicated for beginners. Having said that, this tutorial will only explain how to use named colors (see the examples below).<\/p>\n
<\/a><\/p>\n
Examples: how to make a bar chart plot in matplotlib<\/h2>\n
Ok … now that you know more about the parameters of the plt.bar function, let’s work through some examples of how to make a bar chart with matplotlib.<\/p>\n
I’m going to show you individual examples of how to manipulate each of the important parameters discussed above. <\/p>\n
Run this code before you get started<\/h5>\n
Before you work with the examples, you’ll need to run some code.<\/p>\n
You need to run code to import some Python modules. You’ll also need to run code to create some simple data that we will plot.<\/p>\n
Import modules<\/h6>\n
Here is the code to import the proper modules. <\/p>\n
We’ll be working with matplotlib, numpy, and pyplot, so this code will import them.<\/p>\n
\r\nimport matplotlib\r\nimport numpy as np\r\nimport matplotlib.pyplot as plt\r\n<\/pre>\n
Note that we’ve imported numpy with the nickname
np<\/code>, and we’ve imported pyplot with the nicknameplt<\/code>. These are fairly standard in most Python code. We can use these nicknames as abbreviations of the modules … this just makes it easier to type the code.<\/p>\nCreate dataset<\/h6>\n
Next, you need to create some data that we can plot in the bar chart.<\/p>\n
We’re going to create three sequences of data:
bar_heights<\/code>,bar_labels<\/code>, andbar_x_positions<\/code>. <\/p>\n\r\n# CREATE DATA\r\nbar_heights = [1, 4, 9, 16]\r\nbar_labels = ['alpha', 'beta', 'gamma', 'delta']\r\nbar_x_positions = [0,1,2,3]\r\n<\/pre>\n
As noted above, most of the parameters that we’re going to work with require you to provide a sequence<\/em> of values. Here, all of these sequences have been constructed as Python lists. We could also use tuples or another type of Python sequence. For example, we could use the NumPy arange function<\/a> to create a NumPy array for
bar_heights<\/code> orbar_x_positions<\/code>. As long as the structure is a “sequence” it will work. <\/p>\nOk, now that we have our data, let’s start working with some bar chart examples.<\/p>\n
How to make a simple bar chart with matplotlib<\/h3>\n
Let’s start with a simple example.<\/p>\n
Here, we’re just going to make a simple bar chart with pyplot using the plt.bar function. We won’t do any formatting … this will just produce a bar chart with default formatting.<\/p>\n
To do this, we’re going to call the
plt.bar()<\/code> function and we will setbar_x_positions<\/code> to thex<\/code> parameter andbar_heights<\/code> to theheight<\/code> parameter.<\/p>\n\r\n# PLOT A SIMPLE BAR CHART\r\nplt.bar(bar_x_positions, bar_heights)\r\n<\/pre>\n
And here is the output:<\/p>\n
![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2019\/02\/simple-matplotlib-bar-chart.png\")
<\/p>\nThis is fairly simple, but there are a few details that I need to explain.<\/p>\n
First, notice the position of each of the bars. The bars are at locations 0, 1, 2, and 3 along the x axis. This corresponds to the values stored in
bar_x_positions<\/code> and passed to thex<\/code> parameter.<\/p>\nSecond, notice the height of the bars. The heights are 1, 4, 9, and 16. As should be obvious by now, these bar heights correspond to the values contained in the variable
bar_heights<\/code>, which has been passed to theheight<\/code> parameter.<\/p>\nFinally, notice that we’re passing the values
bar_x_positions<\/code> andbar_heights<\/code> by position<\/em>. When we do it this way, Python knows that the first argument (bar_x_positions<\/code>) corresponds to thex<\/code> parameter and the second argument (bar_heights<\/code>) corresponds to theheight<\/code> parameter. There’s a bit of a quirk with matplotlib that if you make the parameter names explicit with the code by typingplt.bar(x = bar_x_positions, height = bar_heights)<\/code>, you’ll actually get an error. So in this example, you have to put the correct variables in the correct positions inside ofplt.bar()<\/code>, and you have to exclude the actual parameter names.<\/p>\nChange the color of the bars<\/h3>\n
Next, we’ll change the color of the bars.<\/p>\n
This is a very simple modification, but it’s the sort of thing that you can make your plot look better, if you do it right.<\/p>\n
There are a couple different ways to change the color of the bars. You can change the bars to a “named” color, like ‘red,’ ‘green,’ or ‘blue’. Or, you can change the color to a hexidecimal color. Hex colors are a little more complicated, so I’m not going to show you how to use them here. Having said that, hex colors give you more control, so eventually you should become familiar with them.<\/p>\n
Ok. Here, we’re going to make a simple change. We’re going to change the color of the bars to ‘red.’<\/p>\n
To do this, we can just provide a color value to the
color<\/code> parameter:<\/p>\n\r\nplt.bar(bar_x_positions, bar_heights, color = 'red')\r\n<\/pre>\n
The code produces the following output:<\/p>\n
![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2019\/02\/matplotlib-bar-chart-red.png\")
<\/p>\nAdmittedly, this chart doesn’t look that much better than the default, but it gives you a simple example of how to change the bar colors. This code is easy to learn and easy to practice (you should always start with relatively simple examples). <\/p>\n
As you become more skilled with data visualization, you will be able to select other colors that look better for a particular data visualization task. <\/p>\n
The point here is that you can change the color of the bars with the
color<\/code> parameter, and it’s relatively easy.<\/p>\n<\/a><\/p>\n
Change the width of the bars<\/h3>\n
Now, I’ll show you how to change the width of the bars.<\/p>\n
To do this, you can use the
width<\/code> parameter.<\/p>\n\r\nplt.bar(bar_x_positions, bar_heights, width = .5)\r\n<\/pre>\n
And here’s the output:<\/p>\n
![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2019\/02\/matplotlib-bar-chart-width-point5.png\")
<\/p>\nHere, we’ve set the bar widths to .5. In this case, I think that the default (.8) is better. However, there may be situations where the bars are spaced out at larger intervals. In those cases, you’ll need to make your bars wider. My recommendation is that you make the space between the bars about 20% of the width of the bars.<\/p>\n
How to add labels to your bars<\/h3>\n
You might have noticed in the prior examples that there is a bit of a problem with the x-axis of our bar charts: they don’t have labels.<\/p>\n
Let’s take a look by re-creating the simple bar chart from earlier in the tutorial:<\/p>\n
\r\n# ADD X AXIS LABELS\r\nplt.bar(bar_x_positions, bar_heights)\r\n<\/pre>\n
It produces the following bar chart:<\/p>\n
<\/p>\nAgain, just take a look at the bar labels on the x axis. By default, they are just the x-axis positions of the bars. They are not<\/em> the categories.<\/p>\n
In most cases, this will not be okay. <\/p>\n
In almost all cases, when you create a bar chart, the bars need to have labels. Typically, each bar is labeled with an appropriate category.<\/p>\n
How do we do that?<\/p>\n
When you use the plt.bar function from pyplot, you need to set those bar labels manually<\/em>. As you’ve probably noticed, they are not included when you build a basic bar chart like the one we created earlier with the code
plt.bar(bar_x_positions, bar_heights)<\/code>.<\/p>\nHere, I’ll show you how.<\/p>\n
Add bar labels<\/h5>\n
To add labels to your bars, you need to use the plt.xticks function.<\/p>\n
Specifically, you need to call
plt.xticks()<\/code>, and provide two arguments: you need to provide the x axis positions of your bars as well as the labels that correspond to those bars. <\/p>\nSo in this example, we will call the function as follows:
plt.xticks(bar_x_positions, bar_labels)<\/code>. Thebar_x_positions<\/code> variable contains the position of each bar, and thebar_labels<\/code> variable contains the labels of each bar. (Remember that we defined both variables earlier in this tutorial.)<\/p>\n\r\n# ADD X AXIS LABELS\r\nplt.bar(bar_x_positions, bar_heights)\r\nplt.xticks(bar_x_positions, bar_labels)\r\n<\/pre>\n
And here is the result:<\/p>\n
![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2019\/02\/matplotlib-bar-chart-with-bar-labels.png\")
<\/p>\nNotice that each bar now has a categorical label.<\/p>\n
Improve the formatting of your pyplot bar chart<\/h3>\n
Ok, now I’ll show you a quick trick that will improve the appearance of your Python bar charts.<\/p>\n
One of the major issues with standard matplotlib bar charts is that they don’t look all that great. The standard formatting from matplotlib is \u2013 to put it bluntly \u2013 ugly.<\/p>\n
To be clear, the basic formatting is fine if you’re just doing some data exploration at your workstation. The basic formatting is okay if you’re creating charts for personal consumption.<\/p>\n
But if you need to show your charts to anyone important, then the default formatting probably isn’t good enough. The default formatted charts look basic. They lack polish. They are a little unprofessional. You might not understand this, but you need to realize that the appearance of your charts matters when you present them to anyone important.<\/p>\n
That being the case, you need to learn to format your charts properly.<\/p>\n
The full details of how to format your charts is beyond the scope of this post, but here I’ll show you a quick way to dramatically improve the appearance of your pyplot charts.<\/p>\n
Use seaborn formatting to improve your charts<\/h4>\n
We’re going to use a special function from the seaborn package to improve our charts.<\/p>\n
Install seaborn<\/h6>\n
To use this function, you’ll need to install seaborn. You can do that with the following code:<\/p>\n
\r\n# import seaborn module\r\nimport seaborn as sns\r\n<\/pre>\n
Use seaborn.set() to change default formatting<\/h6>\n
Once you have seaborn imported, you can use the seborn.set() function to set new plot defaults for your matplotlib charts. Because we imported seaborn as
sns<\/code>, we can call the function withsns.set()<\/code>. <\/p>\n\r\n#set plot defaults using seaborn formatting\r\nsns.set()\r\n<\/pre>\n
This essentially changes many of the plot defaults like the background color, gridlines, and a few other things.<\/p>\n
Let’s replot our bar chart so you can see what I mean.<\/p>\n
\r\n#plot bar chart\r\nplt.bar(bar_x_positions, bar_heights)\r\n<\/pre>\n
Here’s the plot:<\/p>\n
![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2019\/02\/matplotlib-bar-chart-formatted-with-seaborn.png\")
<\/p>\nI’ll be honest … I think this is dramatically better. Just using this one simple modification makes your matplotlib bar chart look much more professional.<\/p>\n
Run this to remove seaborn formatting<\/h6>\n
One issue that you might run into though is that when you use the seaborn.set() function all of your charts have that formatting. That might not be what you want! <\/p>\n
So how do you revert to the original matplotlib formatting?<\/p>\n
You can do that by running the following code:<\/p>\n
\r\n# REMOVE SEABORN FORMATTING\r\nsns.reset_orig()\r\n<\/pre>\n
If you run this, it will reset the matplotlib formatting back to the original default values.<\/p>\n
Putting the pieces together: an improved matplotlib bar chart<\/h3>\n
Let’s do one more example.<\/p>\n
Here, we’ll use several techniques together to create a more complete and refined bar chart in Python.<\/p>\n
We’ll set the bar positions and heights using the plt.bar function. Then we’ll add the bar labels using, the plt.xticks function. We’ll change the color using the
color<\/code> parameter. And we’ll improve the background formatting by using thesns.set()<\/code> function from seaborn.<\/p>\nLet’s take a look:<\/p>\n
\r\n# COMBINED EXAMPLE \r\nimport seaborn as sns\r\n\r\nsns.set()\r\nplt.bar(bar_x_positions, bar_heights, color = 'darkred')\r\nplt.xticks(bar_x_positions, bar_labels)\r\n<\/pre>\n
And here is the output:<\/p>\n
![\"\"](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2019\/02\/formatted-matplotlib-bar-chart-example.png\")
<\/p>\nLet’s quickly break this down.<\/p>\n
We used the
plt.bar()<\/code> function to create a simple bar chart. The bar locations have been defined with thebar_x_positions<\/code> variable and the bar heights have been defined with thebar_heights<\/code> variable. We set the color of the bars to ‘darkred’ by using thecolor<\/code> parameter. We set the bar category labels by using theplt.xticks<\/code> function. And we improved the overall plot formatting by using thesns.set()<\/code> function.<\/p>\nThere is certainly more that we could do to improve this chart. We could add a plot title, axis titles, and maybe change the fonts.<\/p>\n
Having said that, this looks pretty damn good for a simple bar chart, and it’s only a few lines of code. In my opinion, it’s dramatically better than a simple default bar chart made with matplotlib. <\/p>\n
Make sure to reset the matplotlib defaults!<\/h6>\n
And one last thing … <\/p>\n
As I noted earlier, if you use the
sns.set()<\/code> function to use seaborn formatting for your plots, you may want to reset the defaults afterwards. To do that, run the following code:<\/p>\n\r\n# reset defaults\r\nsns.reset_defaults()\r\n<\/pre>\n
This will return your matplotlib formatting back to the matplotlib defaults.<\/p>\n
If you want to learn data science in Python, learn matplotlib<\/h2>\n
This tutorial should have given you a solid foundation for creating bar charts with matplotlib.<\/p>\n
Having said that, there’s a lot more to learn. If you want to get the most out of matplotlib, you’ll need to learn more tools and more functions. You’ll need to learn more about matplotlib, but you’ll also need to learn more about NumPy and NumPy arrays<\/a>. For example, you’ll often need to use techniques like NumPy linspace to set axis tick locations<\/a>.<\/p>\n
Overall, my point is that there’s more to learn. If you want to be great at data science in Python, you really need to know matplotlib. <\/p>\n
So, this tutorial should be great for helping you learn some of the basics of the matplotlib bar chart, but if you’re really interested in data science, you’ll need to learn quite a bit more.<\/p>\n
For more Python data science tutorials, sign up for our email list<\/h2>\n
If you want to learn more about matplotlib and data science in Python, sign up for our email list.<\/p>\n
When you sign up, you’ll get our tutorials delivered directly to your inbox. Every week, we publish data science tutorials … members of our email list hear about them whenever they are published.<\/p>\n
If you sign up, you’ll get free tutorials about:<\/p>\n
- \n
- Matplotlib<\/li>\n
- NumPy<\/li>\n
- Pandas<\/li>\n
- Base Python<\/li>\n
- Scikit learn<\/li>\n
- Machine learning<\/li>\n
- Deep learning<\/li>\n
- \u2026 and more.<\/li>\n<\/ul>\n
Want to learn data science in Python? Sign up now.<\/p>\n
\n\t\t\t\t
- A quick introduction to the matplotlib histogram<\/a><\/li>\n
- The syntax for the matplotlib bar chart<\/a><\/li>\n