Matplotlib is a pretty extensive library which supports Animations of graphs as well.
The animation tools center around the matplotlib.animation base class, which provides a framework around which the animation functionality is built. The main interfaces are TimedAnimation and FuncAnimation and out of the two, FuncAnimation is the most convenient one to use.

Installation:

• Matplotlib: Refer to MATPLOTLIB Tutorial Series | Part 1
• Numpy: You can install numpy module using following pip command:

  pip install numpy

• FFMPEG: It is required only for saving the animation as a video. The executable can be downloaded from here.

Example 1

# importing required modules
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np

# create a figure, axis and plot element
fig = plt.figure()
ax = plt.axes(xlim=(-50, 50), ylim=(-50, 50))
line, = ax.plot([], [], lw=2)

# initialization function
def init():
    # creating an empty plot/frame
    line.set_data([], [])
    return line,

# lists to store x and y axis points
xdata, ydata = [], []

# animation function
def animate(i):
    # t is a parameter
    t = 0.1*i
    
    # x, y values to be plotted
    x = t*np.sin(t)
    y = t*np.cos(t)
    
    # appending new points to x, y axes points list
    xdata.append(x)
    ydata.append(y)
    
    # set/update the x and y axes data
    line.set_data(xdata, ydata)
    
    # return line object
    return line,
    
# setting a title for the plot
plt.title('A growing coil!')
# hiding the axis details
plt.axis('off')

# call the animator    
anim = animation.FuncAnimation(fig, animate, init_func=init,
                               frames=500, interval=20, blit=True)

# save the animation as mp4 video file
anim.save('animated_coil.mp4', writer = 'ffmpeg', fps = 30)

# show the plot
plt.show()

Here is how the output animation looks like:

Now, let us try to understand the code in pieces:

• fig = plt.figure()
  ax = plt.axes(xlim=(-50, 50), ylim=(-50, 50))
  line, = ax.plot([], [], lw=2)

  Here, we first create a figure, i.e a top level container for all our subplots.
  Then we create an axes element ax which acts as a subplot. The range/limit for x and y axis are also defined while creating the axes element.
  Finally, we create the plot element, named as line . Initially, the x and y axis points have been defined as empty lists and line-width (lw) has been set as 2.

• def init():
      line.set_data([], [])
      return line,

  Now, we declare a initialization function, init . This function is called by animator to create the first frame.

• def animate(i):
      # t is a parameter
      t = 0.1*i
      
      # x, y values to be plotted
      x = t*np.sin(t)
      y = t*np.cos(t)
      
      # appending new points to x, y axes points list
      xdata.append(x)
      ydata.append(y)
      
      # set/update the x and y axes data
      line.set_data(xdata, ydata)
      
      # return line object
      return line,

  This is the most important function of above program. animate() function is called again and again by the animator to create each frame. The number of times this function will be called is determined by number of frames, which is passed as frames argument to animator.
  animate() function takes the index of ith frame as argument.

  t = 0.1*i

  Here, we cleverly use the index of current frame as a parameter!

  x = t*np.sin(t)
  y = t*np.cos(t)

  Now, since we have the parameter t, we can easily plot any parametric equation. For example, here, we are plotting a spiral using its parametric equation.

  line.set_data(xdata, ydata)
  return line,

  Finally, we use set_data() function to set x and y data and then return plot object, line .

• anim = animation.FuncAnimation(fig, animate, init_func=init,
                                 frames=500, interval=20, blit=True)

  Now, we create the FuncAnimation object, anim . It takes various arguments explained below:
  fig : figure to be plotted.
  animate : the function to be called repeatedly for each frame.
  init_func : function used to draw a clear frame. It is called once before the first     frame.
  frames : number of frames. (Note: frames can also be an iterable or generator.)
  interval : duration between frames ( in milliseconds)
  blit : setting blit=True means that only those parts will be drawn, which have changed.

• anim.save('animated_coil.mp4', writer = 'ffmpeg', fps = 30)

  Now, we save the animator object as a video file using save() function.
  You will need a movie writer for saving the animation video.
  In this example, we have used FFMPEG movie writer. So, writer is set as ‘ffmpeg’.
  fps stands for frame per second.

Example 2

This example shows how you can make a rotating curve by applying some simple mathematics!

# importing required modules
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np

# create a figure, axis and plot element
fig = plt.figure()
ax = plt.axes(xlim=(-25, 25), ylim=(-25, 25))
line, = ax.plot([], [], lw=2)

# initialization function
def init():
    # creating an empty plot/frame
    line.set_data([], [])
    return line,

# set of points for a star (could be any curve)
p = np.arange(0, 4*np.pi, 0.1)
x = 12*np.cos(p) + 8*np.cos(1.5*p)
y = 12*np.sin(p) - 8*np.sin(1.5*p)

# animation function
def animate(i):
    # t is a parameter
    t = 0.1*i

    # x, y values to be plotted
    X = x*np.cos(t) - y*np.sin(t)
    Y = y*np.cos(t) + x*np.sin(t)

    # set/update the x and y axes data
    line.set_data(X, Y)

    # return line object
    return line,

# setting a title for the plot
plt.title('A rotating star!')
# hiding the axis details
plt.axis('off')

# call the animator
anim = animation.FuncAnimation(fig, animate, init_func=init,
                               frames=100, interval=100, blit=True)

# save the animation as mp4 video file
anim.save('basic_animation.mp4', writer = 'ffmpeg', fps = 10)

# show the plot
plt.show()

Here is how the output of above program looks like:

• The star shape is obtained by putting k = 2.5 and 0 < t < 4π in the parametric equation given below:
  
  The same has been applied here:

  p = np.arange(0, 4*np.pi, 0.1)
  x = 12*np.cos(p) + 8*np.cos(1.5*p)
  y = 12*np.sin(p) - 8*np.sin(1.5*p)

  You can study more about Hypotrochoids here.

• Now, in each frame, we rotate the star curve using concept of rotation in complex numbers. Let x, y be two ordinates. Then after rotation by angle θ, the new ordinates are:
  
  The same has been applied here:

  X = x*np.cos(t) - y*np.sin(t)
  Y = y*np.cos(t) + x*np.sin(t)

  You can study more about rotation concept here.

All in all, animations are a great tool to create amazing stuff and many more things can be created using them.

So, this was how animated plots can be generated and saved using Matplotlib.
For more examples, refer: animation Examples .

In this part, we will discuss subplots and 3-D plotting.

Subplots

Subplots are required when we want to show two or more plots in same figure. We can do it in two ways using two slightly different methods.

Method 1

# importing required modules
import matplotlib.pyplot as plt
import numpy as np

# function to generate coordinates
def create_plot(ptype):
    # setting the x-axis vaues
    x = np.arange(-10, 10, 0.01)

    # setting the y-axis values
    if ptype == 'linear':
        y = x
    elif ptype == 'quadratic':
        y = x**2
    elif ptype == 'cubic':
        y = x**3
    elif ptype == 'quartic':
        y = x**4

    return(x, y)

# setting a style to use
plt.style.use('fivethirtyeight')

# create a figure
fig = plt.figure()

# define subplots and their positions in figure
plt1 = fig.add_subplot(221)
plt2 = fig.add_subplot(222)
plt3 = fig.add_subplot(223)
plt4 = fig.add_subplot(224)

# plotting points on each subplot
x, y = create_plot('linear')
plt1.plot(x, y, color ='r')
plt1.set_title('$y_1 = x$')

x, y = create_plot('quadratic')
plt2.plot(x, y, color ='b')
plt2.set_title('$y_2 = x^2$')

x, y = create_plot('cubic')
plt3.plot(x, y, color ='g')
plt3.set_title('$y_3 = x^3$')

x, y = create_plot('quartic')
plt4.plot(x, y, color ='k')
plt4.set_title('$y_4 = x^4$')

# adjusting space between subplots
fig.subplots_adjust(hspace=.5,wspace=0.5)

# function to show the plot
plt.show()

Output:

Let us go through this program step by step:

• plt.style.use('fivethirtyeight')

  The styling of plots can be configured by setting different styles available or setting your own. You can learn more about this feature here

• fig = plt.figure()

  Figure acts as a top level container for all plot elements. So, we define a figure as fig which will contain all our subplots.

• plt1 = fig.add_subplot(221)
  plt2 = fig.add_subplot(222)
  plt3 = fig.add_subplot(223)
  plt4 = fig.add_subplot(224)

  Here we use fig.add_subplot method to define subplots and their positions. The function prototype is like this:

  add_subplot(nrows, ncols, plot_number)

  If a subplot is applied to a figure, the figure will be notionally split into ‘nrows’ * ‘ncols’ sub-axes. The parameter ‘plot_number’ identifies the subplot that the function call has to create. ‘plot_number’ can range from 1 to a maximum of ‘nrows’ * ‘ncols’.

  If the values of the three parameters are less than 10, the function subplot can be called with one int parameter, where the hundreds represent ‘nrows’, the tens represent ‘ncols’ and the units represent ‘plot_number’. This means: Instead of subplot(2, 3, 4) we can write subplot(234).

  This figure will make it clear that how positions are specified:
  

• x, y = create_plot('linear')
  plt1.plot(x, y, color ='r')
  plt1.set_title('$y_1 = x$')

  Next, we plot our points on each subplot. First, we generate x and y axis coordinates using create_plot function by specifying the type of curve we want.
  Then, we plot those points on our subplot using .plot method. Title of subplot is set by using set_title method. Using $ at starting and end of the title text will ensure that ‘_'(underscore) is read as a subscript and ‘^’ is read as a superscript.

• fig.subplots_adjust(hspace=.5,wspace=0.5)

  This is another utility method which creates space between subplots.

• plt.show()

  In the end, we call plt.show() method which will show the current figure.

Method 2

# importing required modules
import matplotlib.pyplot as plt
import numpy as np

# function to generate coordinates
def create_plot(ptype):
    # setting the x-axis vaues
    x = np.arange(0, 5, 0.01)

    # setting y-axis values
    if ptype == 'sin':
        # a sine wave
        y = np.sin(2*np.pi*x)
    elif ptype == 'exp':
        # negative exponential function
        y = np.exp(-x)
    elif ptype == 'hybrid':
        # a damped sine wave
        y = (np.sin(2*np.pi*x))*(np.exp(-x))

    return(x, y)

# setting a style to use
plt.style.use('ggplot')

# defining subplots and their positions
plt1 = plt.subplot2grid((11,1), (0,0), rowspan = 3, colspan = 1)
plt2 = plt.subplot2grid((11,1), (4,0), rowspan = 3, colspan = 1)
plt3 = plt.subplot2grid((11,1), (8,0), rowspan = 3, colspan = 1)

# plotting points on each subplot
x, y = create_plot('sin')
plt1.plot(x, y, label = 'sine wave', color ='b')
x, y = create_plot('exp')
plt2.plot(x, y, label = 'negative exponential', color = 'r')
x, y = create_plot('hybrid')
plt3.plot(x, y, label = 'damped sine wave', color = 'g')

# show legends of each subplot
plt1.legend()
plt2.legend()
plt3.legend()

# function to show plot
plt.show()

Output:

Let us go through important parts of this program as well:

• plt1 = plt.subplot2grid((11,1), (0,0), rowspan = 3, colspan = 1)
  plt2 = plt.subplot2grid((11,1), (4,0), rowspan = 3, colspan = 1)
  plt3 = plt.subplot2grid((11,1), (8,0), rowspan = 3, colspan = 1)

  subplot2grid is similar to “pyplot.subplot” but uses 0-based indexing and let subplot to occupy multiple cells.
  Let us try to understand the arguments of the subplot2grid method:
  1. argument 1 : geometry of the grid
  2. argument 2: location of the subplot in the grid
  3. argument 3: (rowspan) No. of rows covered by subplot.
  4. argument 4: (colspan) No. of columns covered by subplot.

  This figure will make this concept more clear:
  

  In our example, each subplot spans over 3 rows and 1 column with two empty rows (row no. 4,8) .

• x, y = create_plot('sin')
  plt1.plot(x, y, label = 'sine wave', color ='b')

  Nothing special in this part as the syntax to plot points on a subplot remains same.

• plt1.legend()

  This will show the label of the subplot on the figure.

• plt.show()

  Finally, we call the plt.show() function to show the current plot.

Note: After going through the above two examples, we can infer that one should use subplot() method when the plots are of uniform size where as subplot2grid() method should be preferred when we want more flexibility on position and sizes of our subplots.

3-D plotting

We can easily plot 3-D figures in matplotlib. Now, we discuss some important and commonly used 3-D plots.

• Plotting points

  from mpl_toolkits.mplot3d import axes3d
  import matplotlib.pyplot as plt
  from matplotlib import style
  import numpy as np
  
  # setting a custom style to use
  style.use('ggplot')
  
  # create a new figure for plotting
  fig = plt.figure()
  
  # create a new subplot on our figure
  # and set projection as 3d
  ax1 = fig.add_subplot(111, projection='3d')
  
  # defining x, y, z co-ordinates
  x = np.random.randint(0, 10, size = 20)
  y = np.random.randint(0, 10, size = 20)
  z = np.random.randint(0, 10, size = 20)
  
  # plotting the points on subplot
  
  # setting labels for the axes
  ax1.set_xlabel('x-axis')
  ax1.set_ylabel('y-axis')
  ax1.set_zlabel('z-axis')
  
  # function to show the plot
  plt.show()

  Output of above program will provide you with a window which can rotate or enlarge the plot. Here is a screenshot: (dark points are nearer than light ones)Let us try to understand some important aspects of this code now.

  from mpl_toolkits.mplot3d import axes3d

  This is the module required to plot on 3-D space.

  ax1 = fig.add_subplot(111, projection='3d')

  Here, we create a subplot on our figure and set projection argument as 3d.

  ax1.scatter(x, y, z, c = 'm', marker = 'o')

  Now we use .scatter() function to plot the points in XYZ plane.

• Plotting lines
  

  # importing required modules
  from mpl_toolkits.mplot3d import axes3d
  import matplotlib.pyplot as plt
  from matplotlib import style
  import numpy as np
  
  # setting a custom style to use
  style.use('ggplot')
  
  # create a new figure for plotting
  fig = plt.figure()
  
  # create a new subplot on our figure
  ax1 = fig.add_subplot(111, projection='3d')
  
  # defining x, y, z co-ordinates
  x = np.random.randint(0, 10, size = 5)
  y = np.random.randint(0, 10, size = 5)
  z = np.random.randint(0, 10, size = 5)
  
  # plotting the points on subplot
  ax1.plot_wireframe(x,y,z)
  
  # setting the labels
  ax1.set_xlabel('x-axis')
  ax1.set_ylabel('y-axis')
  ax1.set_zlabel('z-axis')
  
  plt.show() 

  A screenshot of the 3-D plot of above program will look like:
  The main difference in this program with previous one is:

  ax1.plot_wireframe(x,y,z)

  We used .plot_wireframe() method to plot lines over a given set of 3-D points.

• Plotting Bars

  # importing required modules
  from mpl_toolkits.mplot3d import axes3d
  import matplotlib.pyplot as plt
  from matplotlib import style
  import numpy as np
  
  # setting a custom style to use
  style.use('ggplot')
  
  # create a new figure for plotting
  fig = plt.figure()
  
  # create a new subplot on our figure
  ax1 = fig.add_subplot(111, projection='3d')
  
  # defining x, y, z co-ordinates for bar position
  x = [1,2,3,4,5,6,7,8,9,10]
  y = [4,3,1,6,5,3,7,5,3,7]
  z = np.zeros(10)
  
  # size of bars
  dx = np.ones(10)              # length along x-axis
  dy = np.ones(10)              # length along y-axs
  dz = [1,3,4,2,6,7,5,5,10,9]   # height of bar
  
  # setting color scheme
  color = []
  for h in dz:
      if h > 5:
          color.append('r')
      else:
          color.append('b')
  
  # plotting the bars
  ax1.bar3d(x, y, z, dx, dy, dz, color = color)
  
  # setting axes labels
  ax1.set_xlabel('x-axis')
  ax1.set_ylabel('y-axis')
  ax1.set_zlabel('z-axis')
  
  plt.show()

  A screenshot of the 3-D environment created is here:
  Let us go through important aspects of this program:

  x = [1,2,3,4,5,6,7,8,9,10]
  y = [4,3,1,6,5,3,7,5,3,7]
  z = np.zeros(10)

  Here, we define the base positions of bars. Setting z = 0 means all bars start from XY plane.

  dx = np.ones(10)              # length along x-axis
  dy = np.ones(10)              # length along y-axs
  dz = [1,3,4,2,6,7,5,5,10,9]   # height of bar

  dx, dy, dz denote the size of bar. Consider he bar as a cuboid, then dx, dy, dz are its expansions along x, y, z axis respectively.

  for h in dz:
      if h > 5:
          color.append('r')
      else:
          color.append('b')

  Here, we set the color for each bar as a list. The color scheme is red for bars with height greater than 5 and blue otherwise.

  ax1.bar3d(x, y, z, dx, dy, dz, color = color)

  Finally, to plot the bars, we use .bar3d() function.

• Plotting curves
  

  # importing required modules
  from mpl_toolkits.mplot3d import axes3d
  import matplotlib.pyplot as plt
  from matplotlib import style
  import numpy as np
  
  # setting a custom style to use
  style.use('ggplot')
  
  # create a new figure for plotting
  fig = plt.figure()
  
  # create a new subplot on our figure
  ax1 = fig.add_subplot(111, projection='3d')
  
  # get points for a mesh grid
  u, v = np.mgrid[0:2*np.pi:200j, 0:np.pi:100j]
  
  # setting x, y, z co-ordinates
  x=np.cos(u)*np.sin(v)
  y=np.sin(u)*np.sin(v)
  z=np.cos(v)
  
  # plotting the curve
  ax1.plot_wireframe(x, y, z, rstride = 5, cstride = 5, linewidth = 1)
  
  plt.show()

  Output of this program will look like this:
  
  Here, we plotted a sphere as a mesh grid.
  Let us go through some important parts:

  u, v = np.mgrid[0:2*np.pi:200j, 0:np.pi:100j]

  We use np.mgrid in order to get points so that we can create a mesh.
  You can read more about this here.

  x=np.cos(u)*np.sin(v)
  y=np.sin(u)*np.sin(v)
  z=np.cos(v)

  This is nothing but the parametric equation of a sphere.

  ax1.plot_wireframe(x, y, z, rstride = 5, cstride = 5, linewidth = 1)

  Agan, we use .plot_wireframe() method. Here, rstride and cstride arguments can be used to set how much dense our mesh must be.

So, thats it from me for this series…
Maybe I will write about some more interesting things in future about Matplotlib.
But for now, this is a brief yet concise tutorial series to get started with Matplotlib.

This is the 2nd article in the series which covers graphing in python using matplotlib.

This article will cover different types of plots that we can make using matplotlib.

1. Bar Chart

import matplotlib.pyplot as plt

# x-coordinates of left sides of bars
left = [1, 2, 3, 4, 5]

# heights of bars
height = [10, 24, 36, 40, 5]

# labels for bars
tick_label = ['one', 'two', 'three', 'four', 'five']

# plotting a bar chart
plt.bar(left, height, tick_label = tick_label,
        width = 0.8, color = ['red', 'blue'])

# naming the x-axis
plt.xlabel('x - axis')
# naming the y-axis
plt.ylabel('y - axis')
# plot title
plt.title('My bar chart!')

# function to show the plot
plt.show()

Output of above program looks like this:

• Here, we use plt.bar() function to plot a bar chart.
• x-coordinates of left side of bars are passed along with heights of bars.
• you can also give some name to x-axis coordinates by defining tick_labels

2. Histogram

import matplotlib.pyplot as plt

# frequencies
ages = [2,5,70,40,30,45,50,45,43,40,44,
        60,7,13,57,18,90,77,32,21,20,40]

# setting the ranges and no. of intervals
range = (0, 100)
bins = 10  

# plotting a histogram
plt.hist(ages, bins, range, color = 'red',
        histtype = 'bar', rwidth = 0.8)

# x-axis label
plt.xlabel('age')
# frequency label
plt.ylabel('No. of people')
# plot title
plt.title('My histogram')

# function to show the plot
plt.show()

Output of above program looks like this:

• Here, we use plt.hist() function to plot a histogram.
• frequencies are passed as the ages list.
• Range could be set by defining a tuple containing min and max value.
• Next step is to “bin” the range of values—that is, divide the entire range of values into a series of intervals—and then count how many values fall into each interval. Here we have defined bins = 10. So, there are a total of 100/10 = 10 intervals.

3. Scatter plot

import matplotlib.pyplot as plt

# x-axis values
x = [1,2,3,4,5,6,7,8,9,10]
# y-axis values
y = [2,4,5,7,6,8,9,11,12,12]

# plotting points as a scatter plot
plt.scatter(x, y, label= "stars", color= "m",
            marker= "*", s=30)

# x-axis label
plt.xlabel('x - axis')
# frequency label
plt.ylabel('y - axis')
# plot title
plt.title('My scatter plot!')
# showing legend
plt.legend()

# function to show the plot
plt.show()

Output of above program looks like this:

• Here, we use plt.scatter() function to plot a scatter plot.
• Like a line, we define x and corresponding y – axis values here as well.
• marker argument is used to set the character to use as marker. Its size can be defined using s parameter.

4. Pie-chart

import matplotlib.pyplot as plt

# defining labels
activities = ['eat', 'sleep', 'work', 'play']

# portion covered by each label
slices = [3, 7, 8, 6]

# color for each label
colors = ['r', 'm', 'g', 'b']

# plotting the pie chart
plt.pie(slices, labels = activities, colors=colors,
        startangle=90, shadow = True, explode = (0, 0, 0.1, 0),
        radius = 1.2, autopct = '%1.1f%%')

# plotting legend
plt.legend()

# showing the plot
plt.show()

Output of above program looks like this:

• Here, we plot a pie chart by using plt.pie() method.
• First of all, we define the labels using a list called activities.
• Then, portion of each label can be defined using another list called slices.
• Color for each label is defined using a list called colors.
• shadow = True will show a shadow beneath each label in pie-chart.
• startangle rotates the start of the pie chart by given degrees counterclockwise from the x-axis.
• explode is used to set the fraction of radius with which we offset each wedge.
• autopct is used to format the value of each label. Here, we have set it to show the percentage value only upto 1 decimal place.

5. Plotting curves of given equation

# importing the required modules
import matplotlib.pyplot as plt
import numpy as np

# setting the x - coordinates
x = np.arange(0, 2*(np.pi), 0.1)
# setting the corresponding y - coordinates
y = np.sin(x)

# potting the points
plt.plot(x, y)

# function to show the plot
plt.show()

Output of above program looks like this:

Here, we use NumPy which is a general-purpose array-processing package in python.

• To set the x – axis values, we use np.arange() method in which first two arguments are for range and third one for step-wise increment. The result is a numpy array.
• To get corresponding y-axis values, we simply use predefined np.sin() method on the numpy array.
• Finally, we plot the points by passing x and y arrays to the plt.plot() function.

So, in this part, we discussed various types of plots we can create in matplotlib. There are many more inbuilt plots which haven’t been covered but the most significant ones have been discussed here.

Next parts will cover subplots, styles, basemaps, 3D plotting, etc.

This series will introduce you to graphing in python with Matplotlib, which is arguably the most popular graphing and data visualization library for Python.

Installation

Easiest way to install matplotlib is to use pip. Type following command in terminal:

pip install matplotlib

OR, you can download it from here and install it manually.

Getting started ( Plotting a line)

# importing the required module
import matplotlib.pyplot as plt

# x axis values
x = [1,2,3]
# corresponding y axis values
y = [2,4,1]

# plotting the points
plt.plot(x, y)

# naming the x axis
plt.xlabel('x - axis')
# naming the y axis
plt.ylabel('y - axis')

# giving a title to my graph
plt.title('My first graph!')

# function to show the plot
plt.show()

Output:

The code seems self explanatory. Following steps were followed:

• Define the x-axis and corresponding y-axis values as lists.
• Plot them on canvas using .plot() function.
• Give a name to x-axis and y-axis using .xlabel() and .ylabel() functions.
• Give a title to your plot using .title() function.
• Finally, to view your plot, we use .show() function.

Plotting two or more lines on same plot

import matplotlib.pyplot as plt

# line 1 points
x1 = [1,2,3]
y1 = [2,4,1]
# plotting the line 1 points
plt.plot(x1, y1, label = "line 1")

# line 2 points
x2 = [1,2,3]
y2 = [4,1,3]
# plotting the line 2 points
plt.plot(x2, y2, label = "line 2")

# naming the x axis
plt.xlabel('x - axis')
# naming the y axis
plt.ylabel('y - axis')
# giving a title to my graph
plt.title('Two lines on same graph!')

# show a legend on the plot
plt.legend()

# function to show the plot
plt.show()

Output:

• Here, we plot two lines on same graph. We differentiate between them by giving them a name(label) which is passed as an argument of .plot() function.
• The small rectangular box giving information about type of line and its color is called legend. We can add a legend to our plot using .legend() function.

Customization of Plots

Here, we discuss some elementary customizations applicable on almost any plot.

import matplotlib.pyplot as plt

# x axis values
x = [1,2,3,4,5,6]
# corresponding y axis values
y = [2,4,1,5,2,6]

# plotting the points
plt.plot(x, y, color='green', linestyle='dashed', linewidth = 3,
         marker='o', markerfacecolor='blue', markersize=12)

# setting x and y axis range
plt.ylim(1,8)
plt.xlim(1,8)

# naming the x axis
plt.xlabel('x - axis')
# naming the y axis
plt.ylabel('y - axis')

# giving a title to my graph
plt.title('Some cool customizations!')

# function to show the plot
plt.show()

Output:

As you can see, we have done several customizations like

• setting the line-width, line-style, line-color.
• setting the marker, marker’s face color, marker’s size.
• overriding the x and y axis range. If overriding is not done, pyplot module uses auto-scale feature to set the axis range and scale.

Bar Chart

import matplotlib.pyplot as plt

# x-coordinates of left sides of bars
left = [1, 2, 3, 4, 5]

# heights of bars
height = [10, 24, 36, 40, 5]

# labels for bars
tick_label = ['one', 'two', 'three', 'four', 'five']

# plotting a bar chart
plt.bar(left, height, tick_label = tick_label,
        width = 0.8, color = ['red', 'blue'])

# naming the x-axis
plt.xlabel('x - axis')
# naming the y-axis
plt.ylabel('y - axis')
# plot title
plt.title('My bar chart!')

# function to show the plot
plt.show()

Output :

• Here, we use plt.bar() function to plot a bar chart.
• x-coordinates of left side of bars are passed along with heights of bars.
• you can also give some name to x-axis coordinates by defining tick_labels

Histogram

import matplotlib.pyplot as plt

# frequencies
ages = [2,5,70,40,30,45,50,45,43,40,44,
        60,7,13,57,18,90,77,32,21,20,40]

# setting the ranges and no. of intervals
range = (0, 100)
bins = 10  

# plotting a histogram
plt.hist(ages, bins, range, color = 'red',
        histtype = 'bar', rwidth = 0.8)

# x-axis label
plt.xlabel('age')
# frequency label
plt.ylabel('No. of people')
# plot title
plt.title('My histogram')

# function to show the plot
plt.show()

Output:

• Here, we use plt.hist() function to plot a histogram.
• frequencies are passed as the ages list.
• Range could be set by defining a tuple containing min and max value.
• Next step is to “bin” the range of values—that is, divide the entire range of values into a series of intervals—and then count how many values fall into each interval. Here we have defined bins = 10. So, there are a total of 100/10 = 10 intervals.

Scatter plot

import matplotlib.pyplot as plt

# x-axis values
x = [1,2,3,4,5,6,7,8,9,10]
# y-axis values
y = [2,4,5,7,6,8,9,11,12,12]

# plotting points as a scatter plot
plt.scatter(x, y, label= "stars", color= "m",
            marker= "*", s=30)

# x-axis label
plt.xlabel('x - axis')
# frequency label
plt.ylabel('y - axis')
# plot title
plt.title('My scatter plot!')
# showing legend
plt.legend()

# function to show the plot
plt.show()

Output:

• Here, we use plt.scatter() function to plot a scatter plot.
• Like a line, we define x and corresponding y – axis values here as well.
• marker argument is used to set the character to use as marker. Its size can be defined using s parameter.

Pie-chart

import matplotlib.pyplot as plt

# defining labels
activities = ['eat', 'sleep', 'work', 'play']

# portion covered by each label
slices = [3, 7, 8, 6]

# color for each label
colors = ['r', 'm', 'g', 'b']

# plotting the pie chart
plt.pie(slices, labels = activities, colors=colors,
        startangle=90, shadow = True, explode = (0, 0, 0.1, 0),
        radius = 1.2, autopct = '%1.1f%%')

# plotting legend
plt.legend()

# showing the plot
plt.show()

Output of above program looks like this:

• Here, we plot a pie chart by using plt.pie() method.
• First of all, we define the labels using a list called activities.
• Then, portion of each label can be defined using another list called slices.
• Color for each label is defined using a list called colors.
• shadow = True will show a shadow beneath each label in pie-chart.
• startangle rotates the start of the pie chart by given degrees counterclockwise from the x-axis.
• explode is used to set the fraction of radius with which we offset each wedge.
• autopct is used to format the value of each label. Here, we have set it to show the percentage value only upto 1 decimal place.

Plotting curves of given equation

# importing the required modules
import matplotlib.pyplot as plt
import numpy as np

# setting the x - coordinates
x = np.arange(0, 2*(np.pi), 0.1)
# setting the corresponding y - coordinates
y = np.sin(x)

# potting the points
plt.plot(x, y)

# function to show the plot
plt.show()

Output of above program looks like this:

Here, we use NumPy which is a general-purpose array-processing package in python.

• To set the x – axis values, we use np.arange() method in which first two arguments are for range and third one for step-wise increment. The result is a numpy array.
• To get corresponding y-axis values, we simply use predefined np.sin() method on the numpy array.
• Finally, we plot the points by passing x and y arrays to the plt.plot() function.

So, in this part, we discussed various types of plots we can create in matplotlib. There are many more inbuilt plots which haven’t been covered but the most significant ones have been discussed here.