Plot error bars matplotlib

In this Python tutorial, we will discuss Matplotlib plot error bars in python. Here we will cover different examples related to error bars using matplotlib. And we will also cover the following topics:

• Matplotlib plot error bars
• Matplotlib plot error bars example
• Matplotlib interactive plot error bars
• Matplotlib chart error bars
• Matplotlib scatter plot error bars
• Matplotlib plot_date error bars
• Matplotlib plot only error bars
• Matplotlib plot error bars symmetric
• Matplotlib plot error bars asymmetric
• Matplotlib polar plot error bars

In this section, we are going to learn about the error bar. Before starting error bars firstly, we understand what does error means.

Error is a mistake or we can say that difference between the calculated value and actual value.

When we graphical represent the data, some of the data have irregularity. To indicate these irregularities or uncertainties we use Error Bars.

Basically, error bars are used to represent errors in the graphical plot.

The following steps are used to plot error bars in matplotlib which is outlined below:

• Defining Libraries: Import the libraries which are required to plot error bars (For data creation and manipulation: Numpy, For data visualization: pyplot from matplotlib).
• Define X and Y: Define the data values used for plotting. Data values of x-axis and y-axis.
• Plot error bars: By using the errorbar() method we can plot the error bars.
• Display: Finally we have to use the show() method to display the plot.

The syntax to plot error bars is as below:

matplotlib.pyplot.errorbar(x, y, yerr=None, xerr=None, fmt='', ecolor=None, elinewidth=None, capsize=None, barsabove=False, lolims=False, uplimes=False, xlolims=False, xuplims=False, errorevery=1, capthick=None, * , data=None, **kwargs)

The above-used parameters are outlined as below:

• x: specifies horizontal coordinates of the data points.
• y: specifies vertical coordinates of the data points.
• xerr: Define the horizontal error bar sizes. Must have a float or array-like shape.
• yerr: Define the vertical error bar sizes. Must have a float or array-like shape.
• fmt: Contains string value. By default, this plot error bars with markers. Use ‘none’ to plot error bars without markers.
• ecolor: specifies the color of the error bars.
• elinewidth: specifies linewidth of the error bars.
• capsize: specifies the length of error bars in points or float.
• capthick: specifies the thickness of error bars cap in float or points.
• barsabove: It contains bool value. By default value is False, if the value is True error bars are plotted above the plot symbol.
• lolims,uplims,xlolims,xuplims: specifies that value gives only upper and lower limits. It contains bool value.
• errorevery: It contains integer values and is used to draw error bars on the subset of the data.

First, learn “How to install matplotlib python“.

Matplotlib plot error bars example

In the above sections, we discussed what does error and error bars mean. And we also discussed what are the various steps used to plot error bars.

Let’s understand the concept with the help of an example as below:

# Import Library

import matplotlib.pyplot as plt
  
# Define Data

x= [1, 2, 3, 5]
y= [9, 15, 20, 25]

# Plot error bar

plt.errorbar(x, y, xerr = 0.9)

# Display graph

plt.show()

• In the above, example we import the matplotlib.pyplot library.
• Then we define the x-axis and y-axis data points.
• plt.errorbar() method is used to plot error bars and we pass the argument x, y, and xerr and set the value of xerr = 0.9.
• Then we use plt.show() method to display the error bar plotted graph.

Read: Matplotlib plot a line

Matplotlib plot interactive error bars

Here we format the error bars or we can say that customizing the error bar according to our choice to become our error bar more interactive.

Let’s change the following things in the error bars to become it more interactive:

• fmt: change style of marker. Set it to circle.
• color: change the color of the marker. Set it to orange.
• ecolor: change the color of the error bar. Set it to lightgreen.
• elinewidth: change the line width of the error bar. Set it to 5.
• capsize: change the capsize of the error bar. Set it to 10.

Understand the concept with the help of an example:

# Import Library

import matplotlib.pyplot as plt
  
# Define Data

x= [1, 2, 3, 5]
y= [9, 15, 20, 25]

# Plot error bar

plt.errorbar(x, y, xerr = 0.9, fmt = 'o',color = 'orange', 
            ecolor = 'lightgreen', elinewidth = 5, capsize=10)

# Display graph

plt.show()

• In the above example, we plot the error bars and format them according to above mention list.
• We use plt.errorbar() method to plot error bars and become it more interactive.

Read: Python plot multiple lines using Matplotlib

Matplotlib chart error bars

In this section, we will create a chart plot with error bars using Matplotlib. We use plt.errorbar() method to plot error bars in bar charts.

The following are the cases in the bar chart in which we draw error bars:

• Error in x values
• Error in y values
• Error in both x and y values

Matplotlib chart error bars in x values

By using the plt.errorbar() method we plot the error bars and pass the argument xerr to plot error on the x values.

The syntax for this is:

matplotlib.pyplot.errorbar(x, y, xerr=None)

Let’s understand this concept with the help of an example:

# Import Library

import matplotlib.pyplot as plt
  
# Define Data

x= [6, 15, 2.3, 9]
y= [9, 15, 20, 25]

# Define Error

x_error = [2.3, 5.1, 1, 3.1]

# Plot Bar chart

plt.bar(x,y)

# Plot error bar

plt.errorbar(x, y, xerr = x_error,fmt='o',ecolor = 'red',color='yellow')

# Display graph

plt.show()

• In the above example, we import matplotlib.pyplot library and define the data point on the x-axis and y-axis.
• Then we define the error value and use the plt.bar() method to plot a bar chart.
• plt.errorbar() method is used to plot error bars and we pass xerr as an argument and set its value to be x_error value which we define.

Matplotlib chart error bars in y values

By using the plt.errorbar() method we plot the error bars and pass the argument yerr to plot error on the y values.

The syntax to plot error bars on y values is as given below:

matplotlib.pyplot.errorbar(x, y, yerr=None)

Let’s take an example for better understanding:

# Import Library

import matplotlib.pyplot as plt
  
# Define Data

x= [6, 15, 2.3, 9]
y= [9, 15, 20, 25]

# Define Error

y_error = [2.3, 5.1, 1, 3.1]

# Plot Bar chart

plt.bar(x,y)

# Plot error bar

plt.errorbar(x, y, yerr = y_error,fmt='o',ecolor = 'red',color='yellow')

# Display graph

plt.show()

• In the above example, we import matplotlib.pyplot library
• After this defines the data point on the x-axis and y-axis.
• Then we define the error value and use the plt.bar() method to plot a bar chart and use plt.errorbar() method is used to plot error bars.
• Pass yerr as an argument and set its value to equal y_error value which we define.

Matplotlib chart error bars in x and y values

By using the plt.errorbar() method we plot the error bars and pass the argument xeer and yerr to plot error on both x and y values respectively.

The syntax to plot error bars on both the values is as given below:

matplotlib.pyplot.errorbar(x, y, xerr=None, yerr=None)

Let’s take an example to know how to plot errorbars on both values:

# Import Library

import matplotlib.pyplot as plt
  
# Define Data

x= [6, 15, 2.3, 9]
y= [9, 15, 20, 25]

# Define Error

x_error = [4.2, 6, 10, 8.6]
y_error = [2.3, 5.1, 1, 3.1]

# Plot Bar chart

plt.bar(x,y)

# Plot error bar

plt.errorbar(x, y, xerr = x_error, yerr = y_error,
             fmt='o', ecolor = 'red',color='yellow')

# Display graph


plt.show()

• In the above example, we import matplotlib.pyplot library
• After this defines the data point on the x-axis and y-axis.
• Then we define the error value and use the plt.bar() method to plot a bar chart and use plt.errorbar() method is used to plot error bars.
• Pass xeer, yerr as an argument and set its value to equal x_error, y_error value respectively which we define.

Read: What is matplotlib inline

Matplotlib scatter plot error bars

In this section, we will create a scatter plot with error bars using Matplotlib. We use plt.errorbar() method to plot error bars in scatter plot.

The following are the cases in the scatter plot in which we draw error bars:

• Error in x values
• Error in y values
• Error in both x and y values

Matplotlib scatter plot error bars in x values

By using the plt.errorbar() method we plot the error bars and pass the argument xerr to plot error on the x values in the scatter plot.

The syntax for this is:

matplotlib.pyplot.errorbar(x, y, xerr=None)

Let’s understand this concept with the help of an example:

# Import Library

import matplotlib.pyplot as plt
  
# Define Data

x= [10, 20, 30, 40]
y= [4, 8, 12, 16]

# Define Error

x_error = [2, 4, 6, 8]

# Plot scatter plot

plt.scatter(x,y)

# Plot error bar

plt.errorbar(x, y, xerr = x_error,fmt='o',ecolor = 'cyan',color='black')

# Display graph

plt.show()

• In the above example, we import matplotlib.pyplot library and define the data point on the x-axis and y-axis.
• Then we define the error value and use the plt.scatter() method to draw a scatter plot.
• plt.errorbar() method is used to plot error bars and we pass xerr as an argument and set its value to be x_error value which we define.

Matplotlib scatter plot error bars in y values

By using the plt.errorbar() method we plot the error bars and pass the argument yerr to plot error on the y values in the scatter plot.

The syntax to plot error bars on y values is as given below:

matplotlib.pyplot.errorbar(x, y, yerr=None)

Let’s take an example for better understanding:

# Import Library

import matplotlib.pyplot as plt
  
# Define Data

x= [10, 20, 30, 40]
y= [4, 8, 12, 16]

# Define Error

y_error = [2, 4, 6, 8]

# Plot Scatter Plot

plt.scatter(x,y)

# Plot error bar

plt.errorbar(x, y, yerr = y_error,fmt='o',ecolor = 'cyan',color='black')

# Display graph

plt.show()

• In the above example, we import matplotlib.pyplot library
• After this defines the data point on the x-axis and y-axis.
• Then we define the error value and use the plt.scatter() method to plot a scatter plot and use plt.errorbar() method is used to plot error bars.
• Pass yerr as an argument and set its value to equal y_error value which we define.

Matplotlib scatter plot error bars in x and y values

By using the plt.errorbar() method we plot the error bars and pass the argument xeer and yerr to plot error on both x and y values respectively.

The syntax to plot error bars on both the values is as given below:

matplotlib.pyplot.errorbar(x, y, xerr=None, yerr=None)

Let’s take an example to know how to plot errorbars on both values:

# Import Library

import matplotlib.pyplot as plt
  
# Define Data


x= [10, 20, 30, 40]
y= [4, 8, 12, 16]

# Define Error

x_error= [3, 6, 9, 12]
y_error = [2, 4, 6, 8]

# Plot Scatter Plot

plt.scatter(x,y)

#Plot error bar

plt.errorbar(x, y, xerr= x_error, yerr = y_error,fmt='o',ecolor = 'cyan',color='black')

# Display graph

plt.show()

• In the above example, we import matplotlib.pyplot library
• After this defines the data point on the x-axis and y-axis.
• Then we define the error value and use the plt.scatter() method to plot a scatter plot and use plt.errorbar() method is used to plot error bars.
• Pass xeer, yerr as an argument and set its value to equal x_error, y_error value which we define.

Read: Matplotlib plot bar chart

Matplotlib plot_date error bars

In this section, we will create a dates plot with error bars using Matplotlib. We use plt.errorbar() method to plot error bars.

The following are the cases in the dates plot in which we draw error bars:

• Error in x values
• Error in y values
• Error in both x and y values

Matplotlib plot_date error bars in x values

By using the plt.errorbar() method we plot the error bars and pass the argument xerr to plot error on the x values in the date plot.

The syntax for this is:

matplotlib.pyplot.errorbar(x, y, xerr=None)

Let’s understand this concept with the help of an example:

# Import Library

import matplotlib.pyplot as plt
  
# Define Data

x= [1, 2, 3]
y= [1.5, 2, 2.5]

# Define Error

x_error= 1.5

# Plot Date

plt.plot_date(x,y)

#Plot error bar

plt.errorbar(x, y, xerr= x_error, fmt='o',
             ecolor = 'lightblue',color='m')

# Display graph


plt.tight_layout()

plt.show()

• In the above example, we import matplotlib.pyplot library and define the data point on the x-axis and y-axis.
• Then we define the error value and use the plt.plot_date() method to draw a plot consisting dates.
• plt.errorbar() method is used to plot error bars and we pass xerr as an argument and set its value to be x_error value which we define.

Read: Matplotlib subplot tutorial

Matplotlib plot_date error bars in y values

By using the plt.errorbar() method, we plot the error bars and pass the argument yerr to plot the error on the y values in the date plot.

The syntax to plot error bars on y values is as given below:

matplotlib.pyplot.errorbar(x, y, yerr=None)

Let’s take an example for better understanding:

# Import Library

import matplotlib.pyplot as plt
  
# Define Data


x= [1, 2, 3]
y= [0.5, 0.8, 1]

# Define Error


y_error= 0.1

# Plot Date

plt.plot_date(x,y)

# Plot error bar

plt.errorbar(x, y, yerr= y_error, fmt='o',
             ecolor = 'lightblue',color='m')

# Display graph

plt.tick_params(axis='x', which='major', labelsize=8)

plt.tight_layout()

plt.show()

• In the above example, we import matplotlib.pyplot library
• After this defines the data point on the x-axis and y-axis.
• Then we define the error value and use the plt.plot_date() method to plot a graph consisting of dates and use plt.errorbar() method is used to plot error bars.
• Pass yerr as an argument and set its value to equal y_error value which we define.

Matplotlib plot_date error bars in x and y values

By using the plt.errorbar() method we plot the error bars and pass the argument xeer and yerr to plot error on both x and y values respectively in the date plot.

The syntax to plot error bars on both the values is as given below:

matplotlib.pyplot.errorbar(x, y, xerr=None, yerr=None)

Let’s take an example to know how to plot errorbars on both valuesin date plot:

# Import Library

import matplotlib.pyplot as plt
  
# Define Data

x= [1,2,3]
y= [1.5, 2, 2.5]

# Define Error


x_error= 1.5
y_error = 2.3

# Plot Date

plt.plot_date(x,y)

# Plot error bar


plt.errorbar(x, y, xerr= x_error, yerr = y_error,fmt='o',ecolor = 'lightblue',color='m')

# Display graph


plt.tight_layout()

plt.show()

• In the above example, we import matplotlib.pyplot library
• After this defines the data point on the x-axis and y-axis.
• Then we define the error value and use the plt.plot_date() method to plot a dates and use plt.errorbar() method is used to plot error bars.
• Pass xeer, yerr as an argument and set its value to equal x_error, y_error value which we define.

Read: Matplotlib best fit line

Matplotlib plot only error bars

Here we learn about how we can plot error bars only.

The syntax to plot error bars is:

matplotlib.pyplot.errorbar(x,y,xerr=None,yerr=None)

The parameters used above are:

• x: horizontal coordinates of the data points.
• y: vertical coordinates of the data points.
• xerr: Define the horizontal error bar sizes. Must have a float or array-like shape.
• yerr: Define the vertical error bar sizes. Must have a float or array-like shape.

Let’s take an example to create only error bars:

# Import Library

import matplotlib.pyplot as plt
  
# Define Data

x= [1, 2, 3]
y= [1.5, 2, 2.5]

# Define Error

x_error = 0.2
y_error = 0.5

#Plot error bar

plt.errorbar(x, y, xerr= x_error, yerr = y_error,fmt='o',
             ecolor = 'pink',color='blue')

# Display graph

plt.show()

In the above example, we define the data and error values, and by using the errorbar() method we plot the only error bar graph.

Read: Matplotlib subplots_adjust

Matplotlib plot error bars symmetric

Here we learn what does symmetric error bars are. Errors are constant values and we represent the error values in the array form.

Sometimes, we have a case in which an error differed for each point, but the lower and upper values of error are equal. That type of case is known as the symmetric error bar.

In the symmetric case, the shape of an array is in the form: (N,)

Let’s see the example of symmetric error bars:

# Import library

import numpy as np
import matplotlib.pyplot as plt

# Define Data

x = np.arange(2, 16, 1.5)
y = np.exp(x*2)

# Define Data

error = 0.1 * x

# Plot error

plt.errorbar(x, y, yerr=error, fmt='-o')

# Display Graph

plt.show()

• In the above example, we define data using NumPy arrange() method and exp() method. After that, we define error value in the shape of (N,).
• By using plt.errorbar() method, we plot the symmetric error bars.

Read: Matplotlib log log plot

Matplotlib plot error bars asymmetric

Here we learn what does asymmetric error bars are. Errors are constant values and they are represented in the array form.

Sometimes, we have a case in which an error differed for each point, but the lower and upper limits of error are unequal or different in nature. That type of case is known as the asymmetric error bar.

In the asymmetric case, the shape of an array is in the form: (2, N).

Let’s see the example of asymmetric error bars:

# Import Libraries

import numpy as np
import matplotlib.pyplot as plt

# Define Data

x = np.arange(2, 16, 1.5)
y = np.exp(x*2)

# Define errors

error = 0.1 * x

# Lower limit of error

lower_error = 0.6 * error

# Upper limit of error

upper_error = error

# plot error bars

asymmetric_error = [lower_error, upper_error]
plt.errorbar(x, y, xerr=asymmetric_error, fmt='o')

# Display Graph

plt.show()

In the above example, we define different values of error of lower and upper limits. By using the plt.errorbar() method we plot error bars in asymmetric nature.

Read: Matplotlib plot_date

Matplotlib polar plot error bars

A Cartesian coordinate system is plotted using the polar coordinates. plt.polar() method is used to plot the polar coordinates.

The syntax to plot polar plot is as given below:

matplotlib.pyplot.polar(r, theta)

The parameter used above are:

• r: specifies the distance from the origin.
• theta: Specifies the angle at which distance from the origin has to be measured.

Let’s see an example of plotting error bars in polar coordinates:

# Import Library

import matplotlib.pyplot as plt
import numpy as np
  
# Define Data

r= np.arange(0, 4, 0.5)
theta= 2*np.pi*r

# Define Error

x_error = 0.2
y_error = 5

# Plot polar coordinates

plt.polar(r,theta,"ro")

# Plot error bar

plt.errorbar(r, theta, xerr = x_error, yerr= y_error,                           color='black')    

# Display graph

plt.show()

• In the above example, we import matplotlib and numpy library.
• After that, we define ‘r’ and ‘theta‘ i.e distance and angle.
• Then we plot the polar coordinates by using the plt.polar() method and by using the plt.errorbar() method we plot error bars in the polar plot.
• Finally, we display plt.show() method to display the polar plot.

You may also like to read the following Matplotlib tutorials.

• Matplotlib dashed line
• Matplotlib scatter marker
• Matplotlib change background color
• Matplotlib rotate tick labels
• Matplotlib remove tick labels

In this Python tutorial, we have discussed the “Matplotlib plot error bars” and we have also covered some examples related to it. These are the following topics that we have discussed in this tutorial.

• Matplotlib plot error bars
• Matplotlib plot error bars example
• Matplotlib interactive plot error bars
• Matplotlib chart error bars
• Matplotlib scatter plot error bars
• Matplotlib plot_date error bars
• Matplotlib plot only error bars
• Matplotlib plot error bars symmetric
• Matplotlib plot error bars asymmetric
• Matplotlib polar plot error bars

Bar charts with error bars are useful in engineering to show the confidence or precision in a set of measurements or calculated values. Bar charts without error bars give the illusion that a measured or calculated value is known to high precision or high confidence. In this post, we will build a bar plot using Python and atplotlib. The plot will show the coefficient of thermal expansion (CTE) of three different materials based on a small data set. Then we’ll add error bars to this chart based on the standard deviation of the data.

A bar chart with error bars is shown below. Note the labels on the x-axis and the error bars at the top of each bar.

In order to build this plot, we need a couple of things:

Before you can build the plot, make sure you have the Anaconda Distribution of Python installed on your computer. See installing Anaconda on Windows for installation instructions.

To get going, we’ll use the Anaconda Prompt to create a new virtual environment. Select Anaconda Prompt from the Windows Start Menu. (If using OSX or Linux, the terminal could also be used)

Once you have the Anaconda Prompt open, type the following command to create a new virtual environment:

conda create -n errorbars

Next, to activate our new (errorbars) virtual environment, type the following into the Anaconda Prompt

Now that the errorbars virtual environment is active, you should see (errorbars) in parenthesis before the Anaconda Prompt.

Now we’ll install matplotlib and numpy using conda. (pip will work to install these packages as well) You can write both package names on the same line or use two different conda install lines.

conda install matplotlib numpy

To confirm our (errorbars) virtual environment has matplotlib and numpy installed, run the command:

Now let’s create a new Python script called errorbars.py. At the top of the script we need to import numpy and matplotlib.

# errorbars.py

import numpy as np
import matplotlib.pyplot as plt

Next, we need to read in our data. The chart below shows the measured coefficient of thermal expansion (CTE) of three metals: Aluminum, Copper and Steel. The units for coefficient of thermal expansion is per degrees C ( / °C)

Coefficient of thermal expansion of three metals (units: / °C)

We’ll put this data into three different numpy arrays, one array for each metal. Notice the syntax np.array([ ... ]) has a parenthesis ( followed by a square bracket [. We are passing a Python list, [ denoted with square brackets ] into the numpy array function (argument enclosed in parenthesis).

# Enter raw data
aluminum = np.array([6.4e-5 , 3.01e-5 , 2.36e-5, 3.0e-5, 7.0e-5, 4.5e-5, 3.8e-5, 4.2e-5, 2.62e-5, 3.6e-5])
copper = np.array([4.5e-5 , 1.97e-5 , 1.6e-5, 1.97e-5, 4.0e-5, 2.4e-5, 1.9e-5, 2.41e-5 , 1.85e-5, 3.3e-5 ])
steel = np.array([3.3e-5 , 1.2e-5 , 0.9e-5, 1.2e-5, 1.3e-5, 1.6e-5, 1.4e-5, 1.58e-5, 1.32e-5 , 2.1e-5])

Now we need to calculate the mean (or average) for each of the three material’s CTE using numpy’s np.mean() function. The means will be the height of each bar in our chart.

# Calculate the average
Aluminum_mean = np.mean(aluminum)
Copper_mean = np.mean(copper)
Steel_mean = np.mean(steel)

Next we’ll calculate the standard deviation for each metal using numpy’s np.std() function. On the plot, we will use the standard deviation as the height of our error bars. The positive error will be show as +1 standard deviation above the mean, and the negative error will be shown as -1 standard deviation below the mean.

# Calculate the standard deviation
aluminum_std = np.std(aluminum)
copper_std = np.std(copper)
steel_std = np.std(steel)

There are a couple more things needed to build the plot. We need the names of the metals to go along our x-axis, one name below each bar. We’ll assign the metal names as list of strings in a variable called materials. We also need a variable that contains the means of the coefficients of thermal expansion, the data we are going to plot. We’ll put these into a Python list called CTEs. Our standard deviations will be used for the height of the error bars. The standard deviations will go together in a list called error.

Let’s code all of these Python list into our errorbars.py script.

# Create lists for the plot
materials = ['Aluminum', 'Copper', 'Steel']
x_pos = np.arange(len(materials))
CTEs = [aluminum_mean, copper_mean, steel_mean]
error = [aluminum_std, copper_std, steel_std]

OK. Now it’s time to build the plot. We are going to build a bar chart with three different bars, one bar for each material: Aluminum, Copper and Steel.

First we will create a figure object called fig and an axis object in that figure called ax using matplotlib’s plt.subplots() function. Everything in our plot will be added to the ax (axis) object. Next we put a bar chart on our ax (axis) with the ax.bar() method.

Note the arguments passed into the ax.bar() method:

• x_pos is the array with the count of the number of bars.
• CTEs is our array which contains the means or heights of the bars.
• yerr=error sets the heights of the error bars and the standard deviations.
• keyword arguments (align='center', alpha=0.5, ecolor='black', capsize=10) styles the plot.

We’ll put a label on the y-axis with the title «Coefficient of thermal expansion (°C^-1)» using ax.set_ylabel. We use ax.set_xticks() to feed in our number list to set the bars as numbers 1, 2, 3. Then we add labels to these numbered bars with ax.set_ticklabels(). ax.set_title() and ax.yaxis.grid(True) adds a title and horizontal grid lines.

Finally, we we’ll save the figure to a file called bar_plot_with_error_bars.png using matplotlib’s plt.savefig() function. The plt.thight_layout() method ensures our axis and labels don’t get cut off and are visible.

# Build the plot
fig, ax = plt.subplots()
ax.bar(x_pos, CTEs, yerr=error, align='center', alpha=0.5, ecolor='black', capsize=10)
ax.set_ylabel('Coefficient of Thermal Expansion ($degree C^{-1}$)')
ax.set_xticks(x_pos)
ax.set_xticklabels(materials)
ax.set_title('Coefficent of Thermal Expansion (CTE) of Three Metals')
ax.yaxis.grid(True)

# Save the figure and show
plt.tight_layout()
plt.savefig('bar_plot_with_error_bars.png')
plt.show()

The final plot looks like this:

For any scientific measurement, accurate accounting for errors is nearly as important, if not more important, than accurate reporting of the number itself.
For example, imagine that I am using some astrophysical observations to estimate the Hubble Constant, the local measurement of the expansion rate of the Universe.
I know that the current literature suggests a value of around 71 (km/s)/Mpc, and I measure a value of 74 (km/s)/Mpc with my method. Are the values consistent? The only correct answer, given this information, is this: there is no way to know.

Suppose I augment this information with reported uncertainties: the current literature suggests a value of around 71 $pm$ 2.5 (km/s)/Mpc, and my method has measured a value of 74 $pm$ 5 (km/s)/Mpc. Now are the values consistent? That is a question that can be quantitatively answered.

In visualization of data and results, showing these errors effectively can make a plot convey much more complete information.

Basic Errorbars¶

A basic errorbar can be created with a single Matplotlib function call:

Here the fmt is a format code controlling the appearance of lines and points, and has the same syntax as the shorthand used in plt.plot, outlined in Simple Line Plots and Simple Scatter Plots.

In addition to these basic options, the errorbar function has many options to fine-tune the outputs.
Using these additional options you can easily customize the aesthetics of your errorbar plot.
I often find it helpful, especially in crowded plots, to make the errorbars lighter than the points themselves:

In addition to these options, you can also specify horizontal errorbars (xerr), one-sided errorbars, and many other variants.
For more information on the options available, refer to the docstring of plt.errorbar.

Continuous Errors¶

In some situations it is desirable to show errorbars on continuous quantities.
Though Matplotlib does not have a built-in convenience routine for this type of application, it’s relatively easy to combine primitives like plt.plot and plt.fill_between for a useful result.

Here we’ll perform a simple Gaussian process regression, using the Scikit-Learn API (see Introducing Scikit-Learn for details).
This is a method of fitting a very flexible non-parametric function to data with a continuous measure of the uncertainty.
We won’t delve into the details of Gaussian process regression at this point, but will focus instead on how you might visualize such a continuous error measurement:

We now have xfit, yfit, and dyfit, which sample the continuous fit to our data.
We could pass these to the plt.errorbar function as above, but we don’t really want to plot 1,000 points with 1,000 errorbars.
Instead, we can use the plt.fill_between function with a light color to visualize this continuous error:

Note what we’ve done here with the fill_between function: we pass an x value, then the lower y-bound, then the upper y-bound, and the result is that the area between these regions is filled.

The resulting figure gives a very intuitive view into what the Gaussian process regression algorithm is doing: in regions near a measured data point, the model is strongly constrained and this is reflected in the small model errors.
In regions far from a measured data point, the model is not strongly constrained, and the model errors increase.

For more information on the options available in plt.fill_between() (and the closely related plt.fill() function), see the function docstring or the Matplotlib documentation.

Finally, if this seems a bit too low level for your taste, refer to Visualization With Seaborn, where we discuss the Seaborn package, which has a more streamlined API for visualizing this type of continuous errorbar.

In this article, we learn about the Matplotlib errorbar in Python. The Pyplot module of the Matplotlib library provides MATLAB like interface. And the matplotlib.pyplot.errorbar() function plots y versus x as lines and/or markers with attached errorbars. Moreover, Error bars help to indicate estimated error or uncertainty to give a general sense of how precise a measurement is; this is done through the use of markers drawn over the original graph and its data points. Before we look into examples of Matplotlib errobars and errorbar graphs, let me brief you with the syntax and return the same.

Syantax of matplotlib errorbar()

matplotlib.pyplot.errorbar(x, y, yerr=None, xerr=None, fmt=”, ecolor=None, elinewidth=None, capsize=None, barsabove=False, lolims=False, uplims=False, xlolims=False, xuplims=False, errorevery=1, capthick=None, *, data=None, **kwargs)

Parameters of Matplotlib Errorbar:

• x, y: The horizontal and vertical coordinates of the data points.
• fmt: Contains the string value (Optional)
• xerr, yerr: An array containing errors, and the errors must be positive values.
• ecolor: (default: NONE) In simple words, it’s the color of the errorbar lines. (Optional)
• elinewidth: Linewidth of the errorbar lines with default value NONE. (Optional)
• capsize: Length of the error bar caps in points with default value NONE. (Optional)
• barsabove: (default: False)Contains boolean values for plotting error bars above the plot symbols. (Optional)
• lolims, uplims, xlolims, xuplims: Contains boolean values, which indicate that a value gives only upper/lower limits. (Optional) errorevery: Contain integer values that help draws error bars on a subset of the data. (Optional)

Return type of Matplotlib Errorbar:

The Matplotlib errorbar() function returns a container having:
plotline: Line2D instance of x, y plot markers and/or line.
caplines: Tuple of Line2D instances of the error bar caps.
barlinecols: Tuple of LineCollection with the horizontal and vertical error ranges.

Example of Matplotlib Errorbar in Python

Errorbar helps you to understand the nature of graphs and their convergence. The errorbar can give an idea about the graph’s variance with its mean. Correspondingly, you can identify the outliers from your graph and take care of them. Moreover, it represents uncertainty in your graph.

import numpy as np 
import matplotlib.pyplot as plt 
  
xval = np.arange(0.1, 4, 0.5) 
yval = np.exp(-xval) 
  
plt.errorbar(xval, yval, xerr = 0.4, yerr = 0.5) 
  
plt.title('matplotlib.pyplot.errorbar() function Example') 
plt.show() 

OUTPUT:

EXPLANATION:

Firstly, the above example is a fundamental implementation of the Matplotlib errorbar() function. The ‘xval’ and ‘yval’ contains the horizontal and vertical coordinates of the data points required for errorbar plotting. In addition, the ‘xerr’ and ‘yerr’ are arguments to the errorbar function. The values assigned to them are 0.4 and 0.5, respectively, the positive error values. Finally, these four parameters passed to the errorbar() function are mandatory arguments required to plot any Python errorbars.

Matplotlib Errorbar in Python Multiple lines

It’s very important to be able to plot multiple lines in the same graphs. In the following example, we’ll plot multiple errorbars in the same graph.

import numpy as np 
import matplotlib.pyplot as plt 
   
fig = plt.figure() 
x = np.arange(10) 
y = 3 * np.sin(x / 20 * np.pi) 
yerr = np.linspace(0.05, 0.2, 10) 
   
plt.errorbar(x, y + 7, yerr = yerr, 
             label ='Line1') 
plt.errorbar(x, y + 5, yerr = yerr, 
             uplims = True,  
             label ='Line2') 
plt.errorbar(x, y + 3, yerr = yerr,  
             uplims = True,  
             lolims = True, 
             label ='Line3') 
  
upperlimits = [True, False] * 5
lowerlimits = [False, True] * 5
plt.errorbar(x, y, yerr = yerr, 
             uplims = upperlimits,  
             lolims = lowerlimits, 
             label ='Line4') 
   
plt.legend(loc ='upper left') 
  
plt.title('matplotlib.pyplot.errorbar() 
function Example') 
plt.show() 

OUTPUT:

EXPLANATION:

Firstly, in the above example, the matplotlib errorbar() function creates multiple errorbar lines. The x and y defined are the coordinates of the data points. Along the y-axis, graph plot error. Hence only ‘yerr’ is specified for each line. Additionally, the upper and lower limits indicate the values for only upper and lower limits. Also, the label is an argument indicating the lines as Line1, Line2, etc.

Errorbar graph with error in x

import matplotlib.pyplot as plt  
  
# making a simple plot 
x =[1, 2, 3, 4, 5, 6, 7] 
y =[1, 2, 1, 2, 1, 2, 1] 
  
# creating error 
x_error = 0.5
  
# ploting graph 
plt.plot(x, y) 
plt.errorbar(x, y, 
             xerr = x_error, 
             fmt ='o') 

OUTPUT:

EXPLANATION:

Firstly, in the above example, x and y are arrays defined containing x and y coordinates to plot the graph. Additionally, the ‘x_error’ is 0.5, which introduces errors only along the x-axis. The x, y, and xerr are the mandatory parameters passed to the Matplotlib errorbar in Python. The optional parameter ‘fmt’ containing string value is also passed.

Errorbar graph with error in y

import matplotlib.pyplot as plt  
  
  
# making a simple plot 
x =[1, 2, 3, 4, 5, 6, 7] 
y =[1, 2, 1, 2, 1, 2, 1] 
  
# creating error 
y_error = 0.2
  
# ploting graph 
plt.plot(x, y) 
  
plt.errorbar(x, y, 
             yerr = y_error, 
             fmt ='o') 

OUTPUT:

EXPLANATION:

Firstly, in the above example, x and y are arrays defined containing x and y coordinates to plot the graph. The ‘y_error’ is 0.2, which introduces errors only along the y-axis. The x, y, and yerr are the mandatory parameters passed to the errorbar function. The optional parameter ‘fmt’ containing string value is also passed.

Errorbar graph with Variable error in x and y

import matplotlib.pyplot as plt 
  
x =[1, 2, 3, 4, 5] 
y =[1, 2, 1, 2, 1] 
  
y_errormin =[0.1, 0.5, 0.9, 
             0.1, 0.9] 
y_errormax =[0.2, 0.4, 0.6,  
             0.4, 0.2] 
  
x_error = 0.5
y_error =[y_errormin, y_errormax] 
  
# ploting graph 
# plt.plot(x, y) 
plt.errorbar(x, y, 
             yerr = y_error, 
             xerr = x_error,  
             fmt ='o') 

OUTPUT:

EXPLANATION:

The above example depicts an error bar graph plot for variable errors. Likewise, the x and y are two arrays defined containing the coordinate points. The error along the x-axis is 0.5. Simultaneously, the error along the y-axis between two arrays is y_errormin and y_errormax. These parameters are arguments to the Matplotlib errorbar function to get the desired output.

Conclusion

This article clearly presents to you different ways of using the Matplotlib errorbar in Python. Examples of both errorbar lines and graphs are provided with a detailed explanation. Errorbars provide an additional layer of detail on the presented data. Refer to this article for any queries related to the Matplotlib errorbar() function.

However, if you have any doubts or questions, do let me know in the comment section below. I will try to help you as soon as possible.

Happy Pythoning!