How To Install Matplotlib In Python 3.7

Matplotlib - An Intro to Creating Graphs with Python

Data visualizations are an important method of sharing your data with others. Some people refer to visualizations equally plots, charts, or graphs. These names are synonymous in this commodity.

Python has many 3rd political party packages that exercise data visualizations. In fact, there are so many that it can be somewhat overwhelming. One of the oldest and most popular is Matplotlib. Matplotlib is known for creating static, blithe, and interactive visualizations in Python.

You tin can create many unlike types of plots and charts with Matplotlib. Information technology also integrates well with other data science and math libraries like NumPy and pandas. You lot volition too detect that Matplotlib works with most of Python's GUI toolkits, such every bit Tkinter, wxPython and PyQt. Because Matplotlib is and then well known, it will be the graphing package that is covered in this article.

You will exist learning about the following topics:

• Creating a Uncomplicated Line Chart with PyPlot
• Creating a Bar Chart
• Creating a Pie Chart
• Calculation Labels
• Adding Titles to Plots
• Creating a Legend
• Showing Multiple Figures

Permit's beginning plotting with Matplotlib!

Installing Matplotlib

You will need to install Matplotlib to be able to use it. Fortunately, that is easy to exercise with pip:

                python -m pip install matplotlib                              

This will install Matplotlib also as whatever dependencies that information technology requires. Now you are prepare to offset graphing!

Creating a Simple Line Chart with PyPlot

Creating charts (or plots) is the main purpose of using a plotting package. Matplotlib has a sub-module called pyplot that yous will exist using to create a chart. To get started, go ahead and create a new file named line_plot.py and add the following lawmaking:

# line_plot.py  import matplotlib.pyplot equally plt  def line_plot(numbers):     plt.plot(numbers)     plt.ylabel('Random numbers')     plt.prove()  if __name__ == '__main__':     numbers = [two, four, ane, 6]     line_plot(numbers)            

Here yous import matplotlib.pyplot as plt. Then you create a line_plot() which takes in a Python list of numbers. To plot the numbers, you use the plot() function. Yous as well add a characterization to the y-centrality. Finally, you phone call show() to display the plot.

You should now encounter a window that looks like this:

Now you know how to create a simple line nautical chart using Matplotlib! Now you volition discover out how to make a bar nautical chart in the next section.

Creating a Bar Nautical chart

Creating a bar chart with Matplotlib is very like to how you lot created a line plot. It simply takes a few extra arguments. Go alee and create a new file named bar_chart.py and enter the following code into it:

# bar_chart.py  import matplotlib.pyplot as plt  def bar_chart(numbers, labels, pos):     plt.bar(pos, numbers, colour='blue')     plt.xticks(ticks=pos, labels=labels)     plt.show()  if __name__ == '__main__':     numbers = [2, ane, iv, 6]     labels = ['Electric', 'Solar', 'Diesel', 'Unleaded']     pos = list(range(iv))     bar_chart(numbers, labels, pos)            

When you create a bar chart using bar(), you laissez passer in a list of values for the 10-axis. Then you pass in a list of heights for the confined. Yous can also optionally set a color for the bars. In this case, y'all prepare them to "blue". Next, y'all prepare the xticks(), which are the tick marks that should appear along the x-axis. You lot also pass in a list of labels that correspond to the ticks.

Go alee and run this code and y'all should encounter the post-obit graph:

You lot can too make a horizontal bar chart with Matplotlib. All you need to do is change bar() to barh(). Create a new file named bar_chartsh.py and add this code:

# bar_charth.py  import matplotlib.pyplot as plt  def bar_charth(numbers, labels, pos):     plt.barh(pos, numbers, color='bluish')     plt.yticks(ticks=pos, labels=labels)     plt.show()  if __name__ == '__main__':     numbers = [two, 1, 4, 6]     labels = ['Electric', 'Solar', 'Diesel', 'Unleaded']     pos = listing(range(4))     bar_charth(numbers, labels, pos)            

There is one other sneaky change here. Can you spot it? The alter is that since it is at present a horizontal bar chart, yous will want to set the yticks() instead of the xticks() or information technology won't look quite right.

Once you have it all set up to go, run the code and you will run into the following:

That looks great and it didn't accept very much code at all! Now let'due south find out how to create a pie chart with Matplotlib.

Creating a Pie Chart

Pie charts are a bit of a different creature. To create a pie chart, you will be using Matplotlib'southward subplots() part, which returns a Figure and an Axes object. To see how that works, create a new file named pie_chart_plain.py and put this code in it:

# pie_chart_plain.py  import matplotlib.pyplot as plt  def pie_chart():     numbers = [40, 35, 15, 10]     labels = ['Python', 'Ruby', 'C++', 'PHP']      fig1, ax1 = plt.subplots()     ax1.pie(numbers, labels=labels)     plt.bear witness()  if __name__ == '__main__':     pie_chart()            

In this code, you create subplots() and so utilise the pie() method of the Axes object. Y'all pass in a list of numbers as you did before, as well as a list of labels. And so when you run the code, you volition see your pie nautical chart:

That'southward pretty nice for such a short piece of code. Merely you can make your pie charts look even amend. Create a new file named pie_chart_fancy.py and add this code to see how:

# pie_chart_fancy.py  import matplotlib.pyplot equally plt  def pie_chart():     numbers = [40, 35, xv, 10]     labels = ['Python', 'Ruby', 'C++', 'PHP']     # Explode the first piece (Python)     explode = (0.ane, 0, 0, 0)      fig1, ax1 = plt.subplots()     ax1.pie(numbers, explode=explode, labels=labels,             shadow=Truthful, startangle=ninety,             autopct='%one.1f%%')     ax1.axis('equal')     plt.show()  if __name__ == '__main__':     pie_chart()            

For this example, you lot utilise the explode parameter to tell the pie chart to "explode" or remove a slice from the pie. In this example, you remove the first piece, which corresponds to "Python". You also add a shadow to the pie chart. You can tell your pie chart to rotate a certain number of degrees counter-clockwise by setting the startangle. If you'd similar to prove the slice percentages, you can utilise autopct, which volition use Python'due south string interpolation syntax.

When yous run this code, your pie chart volition now look like this:

Isn't that nifty? Your pie chart now looks much more than polished! At present it's time to learn how to add labels to your other graphs!

Adding Labels

When yous are graphing data, you will ordinarily want to characterization the axes. Y'all can characterization the x-centrality past using the xlabel() function and you can characterization the y-axis by using the corresponding ylabel() function. To meet how this works, create a file named bar_chart_labels.py and add this code to it:

# bar_chart_labels.py  import matplotlib.pyplot as plt  def bar_chart(numbers, labels, pos):     plt.bar(pos, numbers, color='blue')     plt.xticks(ticks=pos, labels=labels)     plt.xlabel('Vehicle Types')     plt.ylabel('Number of Vehicles')     plt.show()  if __name__ == '__main__':     numbers = [ii, 1, four, 6]     labels = ['Electric', 'Solar', 'Diesel', 'Unleaded']     pos = list(range(4))     bar_chart(numbers, labels, pos)            

Here you call both xlabel() and ylabel() and set them to different strings. This adds some explanatory text underneath the graph and to the left of the graph, respectively. Hither is what the result looks like:

That looks quite nice. Your graph is easier to understand, but it is missing a title. You will larn how to do that in the next section!

Adding Titles to Plots

Calculation titles to your graphs with Matplotlib is quite straightforward. In fact, all yous need to do is use the title() function to add ane. To detect out how, create a new file named bar_chart_title.py and add together this lawmaking to it:

# bar_chart_title.py  import matplotlib.pyplot equally plt  def bar_chart(numbers, labels, pos):     plt.bar(pos, [4, five, 6, 3], color='green')     plt.bar(pos, numbers, colour='blueish')     plt.xticks(ticks=pos, labels=labels)     plt.title('Gas Used in Various Vehicles')     plt.xlabel('Vehicle Types')     plt.ylabel('Number of Vehicles')     plt.show()  if __name__ == '__main__':     numbers = [2, one, iv, 6]     labels = ['Electric', 'Solar', 'Diesel', 'Unleaded']     pos = listing(range(4))     bar_chart(numbers, labels, pos)            

The primary modify here is on line 9 where you call championship() and laissez passer in a string. This sets the title for the graph and centers it along the top by default. You lot can change the location slightly by setting the loc parameter to "left" or "right", merely you can't specify that the title be anywhere but the top. There is also a fontdict parameter that you can use for decision-making the appearance of the title font.

You besides add together a new bar plot to the graph. This helps you see what a stacked bar plot looks like and also prepares you for the next section.

Here is what your graph looks like now:

This graph looks fifty-fifty meliorate, but information technology'southward however missing something. Oh! You demand a legend! Permit'southward find out how to do that next.

Creating a Legend

Adding a legend to your Matplotlib graph is too straightforward. Yous will use the fable() function to add 1. Create a new file named bar_chart_legend.py. Then, add this lawmaking to information technology:

# bar_chart_legend.py  import matplotlib.pyplot as plt  def bar_chart(numbers, labels, pos):     plt.bar(pos, [4, v, half-dozen, 3], color='dark-green')     plt.bar(pos, numbers, color='blue')     plt.xticks(ticks=pos, labels=labels)     plt.xlabel('Vehicle Types')     plt.ylabel('Number of Vehicles')     plt.legend(['First Label', 'Second Label'], loc='upper left')     plt.show()  if __name__ == '__main__':     numbers = [2, 1, 4, 6]     labels = ['Electric', 'Solar', 'Diesel', 'Unleaded']     pos = listing(range(iv))     bar_chart(numbers, labels, pos)            

Here you add a legend() right earlier you show() the graph. When y'all create a legend, you can gear up the labels by passing in a list of strings. The list should friction match the number of plots in your graph. Y'all can too set the location of the fable by using the loc parameter.

When you run this code, you lot will come across your graph updated to expect similar this:

Now your graph has all the normal components that you would expect to have in a graph. At this point you've already seen a lot of tasks y'all can accomplish using Matplotlib. The concluding topic to learn about is how to add multiple figures with Matplotlib.

Showing Multiple Figures

Matplotlib allows you to create several plots before you bear witness them. This lets you work with multiple datasets at in one case. At that place are several dissimilar ways you can practise this. You will expect at ane of the simplest ways to practise so.

Create a new file named multiple_figures.py and add this code:

# multiple_figures.py  import matplotlib.pyplot as plt  def line_plot(numbers, numbers2):     first_plot = plt.figure(ane)     plt.plot(numbers)      second_plot = plt.effigy(two)     plt.plot(numbers2)     plt.show()  if __name__ == '__main__':     numbers = [2, four, 1, half-dozen]     more_numbers = [5, 1, 10, 3]     line_plot(numbers, more_numbers)            

Here you create 2 line plots. Before you plot, y'all phone call figure(), which creates a top-level container for the plots that follow later it is called. Thus the first plot is added to figure one and the 2nd plot information technology added to figure two. When you and then call testify() at the end, Matplotlib will open ii windows with each graph shown separately.

Run the code and you volition run across the following two windows on your auto:

Matplotlib also supports adding two or more plots to a single window. To see how that works, create another new file and proper noun this one multiple_plots.py. To make things more than interesting, you lot will utilize NumPy in this example to create the two plots.

Note: If you lot haven't already, you will need to install NumPy to become this example to piece of work.

This example is based on ane from the Matplotlib documentation:

# multiple_plots.py  import matplotlib.pyplot as plt import numpy as np  def multiple_plots():     # Some example data to display     x = np.linspace(0, 2 * np.pi, 400)     y = np.sin(x ** ii)      fig, axs = plt.subplots(2)     fig.suptitle('Vertically stacked subplots')     axs[0].plot(10, y)     axs[ane].plot(x, -y)     plt.show()  if __name__ == '__main__':     multiple_plots()            

Here yous create what amounts to two split up sine wave graphs. To make them both show upward in the same window, you utilize a phone call to subplots(), which is a handy utility for creating multiple figures in a unmarried call. You can then use the Axes object that information technology returns to plot the data you created with NumPy.

The result ends up looking like this:

If you lot don't want to use NumPy, you could plot the two sets of numbers from the previous example. In fact, you should try that. Go alee and create a new file named multiple_plots2.py and add this code:

# multiple_plots2.py  import matplotlib.pyplot every bit plt  def multiple_plots():     numbers = [2, 4, 1, 6]     more_numbers = [five, 1, ten, 3]     fig, axs = plt.subplots(two)     fig.suptitle('Vertically stacked subplots')     axs[0].plot(numbers)     axs[1].plot(more_numbers)     plt.show()  if __name__ == '__main__':     multiple_plots()            

In this lawmaking, you remove the NumPy code entirely and add the two lists of numbers from the earlier example. And so you plot them using the Axes object.

This results in the post-obit stacked plot:

At this signal, you should have a pretty good handle on how to create multiple figures and stacked plots with Matplotlib.

Wrapping Upwardly

Matplotlib is a smashing parcel that you tin can use to create all kinds of nifty graphs. It's amazing how few lines of code y'all need to write to create a useful plot from your information. In this commodity, you learned nigh the following topics:

• Creating a Unproblematic Line Chart with PyPlot
• Creating a Bar Chart
• Creating a Pie Chart
• Adding Labels
• Calculation Titles to Plots
• Creating a Legend
• Showing Multiple Figures

Matplotlib is very powerful and has many features that are not covered here. You lot can create many other types of visualizations with Matplotlib. There is a newer package called Seaborn that is built on top of Matplotlib and makes its graphs expect even nicer. At that place are also many other completely separate graphing packages for Python. Yous will discover that Python has support for almost whatsoever blazon of graph you lot tin can think of and probably many yous didn't know existed.

Related Reading

Want to larn more about what yous can do with Python? Cheque out these tutorials:

• Python 101: An Intro to Working with JSON

• Python 101 - Creating Multiple Processes

• Python 101 – Debugging Your Code with pdb

• Python 101 – Launching Subprocesses with Python

Source: https://www.blog.pythonlibrary.org/2021/09/07/matplotlib-an-intro-to-creating-graphs-with-python/

Posted by: martinhicave.blogspot.com

Share this post