lOMoARcPSD|36553333

UNIT 2 VISUALIZING USING MATPLOTLIB

Importing Matplotlib - Line plots - Scatter plots - visualizing errors - density

and contour plots Histograms - legends - colors - subplots - text and annotation
customization three-dimensional plotting - Geographic Data with Basemap -
Visualization with Seaborn.
Importing Matplotlib
• Matplotlib is a cross-platform, data visualization and graphical plotting library
for Python and its numerical extension NumPy.
• Matplotlib is a comprehensive library for creating static, animated, and
interactive visualizations in Python.
• Matplotlib is a plotting library for the Python programming language. It
allows to make quality charts in few lines of code. Most of the other python
plotting library are built on top of Matplotlib.
• The library is currently limited to 2D output, but it still provides you with the
means to express graphically the data patterns.
Visualizing Information: Starting with Graph
• Data visualization is the presentation of quantitative information in a graphical
form. In other words, data visualizations turn large and small datasets into
visuals that are easier for the human brain to understand and process.
• Good data visualizations are created when communication, data science, and
design collide. Data visualizations done right offer key insights into
complicated datasets in ways that are meaningful and intuitive.
• A graph is simply a visual representation of numeric data. MatPlotLib supports
a large number of graph and chart types.
• Matplotlib is a popular Python package used to build plots. Matplotlib can also
be used to make 3D plots and animations.
• Line plots can be created in Python with Matplotlib's pyplot library. To build a
line plot, first import Matplotlib. It is a standard convention to import
Matplotlib's pyplot library as plt.
 lOMoARcPSD|36553333

• To define a plot, you need some values, the matplotlib.pyplot module, and an
idea of what you want to display.
import matplotlib.pyplot as plt
plt.plot([1,2,3],[5,7,4])
plt.show()
• The plt.plot will "draw" this plot in the background, but we need to bring it to
the screen when we're ready, after graphing everything we intend to.
• plt.show(): With that, the graph should pop up. If not, sometimes can pop
under, or you may have gotten an error. Your graph should look like :

• This window is a matplotlib window, which allows us to see our graph, as well
as interact with it and navigate it
Line Plot
• More than one line can be in the plot. To add another line, just call the plot
(x,y) function again. In the example below we have two different values for y
(y1, y2) that are plotted onto the chart.
import matplotlib.pyplot as
plt import numpy as np
 lOMoARcPSD|36553333

x = np.linspace(-1, 1, 50)
y1 = 2*x+ 1
y2 = 2**x + 1
plt.figure(num = 3, figsize=(8, 5))
plt.plot(x, y2)
plt.plot(x, y1,
linewidth=1.0,
linestyle='--'
)
plt.show()
• Output of the above code will look like this:

Example 5.1.1: Write a simple python program that draws a line graph
where x = [1,2,3,4] and y = [1,4,9,16] and gives both axis label as "X-axis"
and "Y-axis".
Solution:
importmatplotlib.pyplot as plt
importnumpy as np
# define data values
x = np.array([1, 2, 3, 4]) # X-axis points
y = x*2 # Y-axis points
print("Values of :")
print("Values of
Y):")
 lOMoARcPSD|36553333

print (Y)
plt.plot(X, Y)
# Set the x axis label of the current axis.
plt.xlabel('x-axis')
# Set the y axis label of the current axis.
plt.ylabel('y-axis')
# Set a title
plt.title('Draw a line.')
# Display the figure.
plt.show()
Saving Work to Disk
• Matplotlib plots can be saved as image files using the plt.savefig() function.
• The .savefig() method requires a filename be specified as the first argument.
This filename can be a full path. It can also include a particular file extension if
desired. If no extension is provided, the configuration value of savefig.format is
used instead.
• The .savefig() also has a number of useful optional arguments :
1. dpi can be used to set the resolution of the file to a numeric value.
2. transparent can be set to True, which causes the background of the chart to be
transparent.
3. bbox_inches can be set to alter the size of the bounding box (whitespace)
around the output image. In most cases, if no bounding box is desired, using
bbox_inches = 'tight' is ideal.
4. If bbox_inches is set to 'tight', then the pad_inches option specifies the
amount of padding around the image.
Setting the Axis, Ticks, Grids
• The axes define the x and y plane of the graphic. The x axis runs horizontally,
and the y axis runs vertically.
• An axis is added to a plot layer. Axis can be thought of as sets of x and y axis
that lines and bars are drawn on. An Axis contains daughter attributes like axis
labels, tick labels, and line thickness.
 lOMoARcPSD|36553333

• The following code shows how to obtain access to the axes for a
plot : fig = plt.figure()
axes = fig.add_axes([0.1, 0.1, 0.8, 0.8]) # left, bottom, width, height (range 0 to
1)
axes.plot(x, y, 'r')
axes.set_xlabel('x')
axes.set_ylabel('y')
axes.set_title('title');
Output:

• A grid can be added to a Matplotlib plot using the plt.grid() command. By

defaut, the grid is turned off. To turn on the grid use:
plt.grid(True)
• The only valid options are plt.grid(True) and plt.grid(False). Note that True
and False are capitalized and are not enclosed in quotes.
Defining the Line Appearance and Working with Line Style
• Line styles help differentiate graphs by drawing the lines in various ways.
Following line style is used by Matplotlib.
• Matplotlib has an additional parameter to control the colour and style of the
plot.
plt.plot(xa, ya 'g')
 lOMoARcPSD|36553333

• This will make the line green. You can use any colour of red, green, blue,
cyan, magenta, yellow, white or black just by using the first character of the
colour name in lower case (use "k" for black, as "b" means blue).
• You can also alter the linestyle, for example two dashes -- makes a dashed
line. This can be used added to the colour selector, like this:
plt.plot(xa, ya 'r--')
• You can use "-" for a solid line (the default), "-." for dash-dot lines, or ":" for a
dotted line. Here is an example :
from matplotlib import pyplot as plt
import numpy as np
xa = np.linspace(0, 5, 20)
ya = xa**2
plt.plot(xa, ya, 'g')
ya = 3*xa
plt.plot(xa, ya,
'r--') plt.show()
Output:
 lOMoARcPSD|36553333

• MatPlotLib Colors are as follows:

Adding Markers
• Markers add a special symbol to each data point in a line graph. Unlike line
style and color, markers tend to be a little less susceptible to accessibility and
printing issues.
• Basically, the matplotlib tries to have identifiers for the markers which look
similar to the marker:
1. Triangle-shaped: v, <, >
Λ 2. Cross-like: *,+, 1, 2, 3,
4
3. Circle-like: 0,., h, p, H, 8
• Having differently shaped markers is a great way to distinguish between
different groups of data points. If your control group is all circles and your
experimental group is all X's the difference pops out, even to colorblind
viewers.
 lOMoARcPSD|36553333

N = x.size // 3
ax.scatter(x[:N], y[:N], marker="o")
ax.scatter(x[N: 2* N], y[N: 2* N], marker="x")
ax.scatter(x[2* N:], y[2 * N:], marker="s")
• There's no way to specify multiple marker styles in a single scatter() call, but
we can separate our data out into groups and plot each marker style separately.
Here we chopped our data up into three equal groups.

Using Labels, Annotations and Legends

• To fully document your graph, you usually have to resort to labels,
annotations, and legends. Each of these elements has a different purpose, as
follows:
1. Label: Make it easy for the viewer to know the name or kind of data
illustrated
2. Annotation: Help extend the viewer's knowledge of the data, rather than
simply identify it.
3. Legend: Provides cues to make identification of the data group easier.
• The following example shows how to add labels to your
graph: values = [1, 5, 8, 9, 2, 0, 3, 10, 4, 7]
import matplotlib.pyplot as plt
plt.xlabel('Entries')
plt.ylabel('Values')
 lOMoARcPSD|36553333

plt.plot(range(1,11),
values) plt.show()
• Following example shows how to add annotation to a
graph: import matplotlib.pyplot as plt
W=4
h=3
d = 70
plt.figure(figsize=(w, h),
dpi=d) plt.axis([0, 5, 0, 5])
x = [0, 3, 5]
y = [1, 4, 3.5]
label_x = 1
label_y = 4
arrow_x = 3
arrow_y= 4
arrow_properties=dict( faceco
lor="black", width=0.5,
headwidth=4, shrink=0.1)
plt.annotate("maximum", xy=(arrow_x, arrow_y),
xytext=(label_x, label_y),
arrowprops arrow_properties)
plt.plot(x, y)
plt.savefig("out.png")
Output:
 lOMoARcPSD|36553333

Creating a legend
• There are several options available for customizing the appearance and
behavior of the plot legend. By default the legend always appears when there
are multiple series and only appears on mouseover when there is a single series.
By default the legend shows point values when the mouse is over the graph but
not when the mouse leaves.
• A legend documents the individual elements of a plot. Each line is presented
in a table that contains a label for it so that people can differentiate between
each line.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-10, 9, 20)
y = x ** 3
Z = x ** 2
figure = plt.figure()
axes = figure.add_axes([0,0,1,1])
axes.plot(x, z, label="Square Function")
axes.plot(x, y, label="Cube Function")
axes.legend()
• In the script above we define two functions: square and cube using x, y and z
variables. Next, we first plot the square function and for the label parameter, we
pass the value Square Function.
 lOMoARcPSD|36553333

• This will be the value displayed in the label for square function. Next, we plot
the cube function and pass Cube Function as value for the label parameter.
• The output looks likes this:

A scatter plot is a visual representation of how two variables relate to each

other.
Scatter Plots
• A scatter plot is a visual representation of how two variables relate to each
other. we can use scatter plots to explore the relationship between two variables,
for example by looking for any correlation between them.
• Matplotlib also supports more advanced plots, such as scatter plots. In this
case, the scatter function is used to display data values as a collection of x, y
coordinates represented by standalone dots.
Import matplotlib.pyplot as plt
#X axis values:
x = [2,3,7,29,8,5,13,11,22,33]
# Y axis values:
y = [4,7,55,43,2,4,11,22,33,44]
# Create scatter plot:
plt.scatter(x, y)
plt.show()
 lOMoARcPSD|36553333

• Comparing plt.scatter() and plt.plot(): We can also produce the scatter plot
shown above using another function within matplotlib.pyplot.
Matplotlib'splt.plot() is a general-purpose plotting function that will allow user
to create various different line or marker plots.
• We can achieve the same scatter plot as the one obtained in the section above
with the following call to plt.plot(), using the same data:
plt.plot(x, y,
"o") plt.show()
• In this case, we had to include the marker "o" as a third argument, as
otherwise plt.plot() would plot a line graph. The plot created with this code is
identical to the plot created earlier with plt.scatter().
. • Here's a rule of thumb that can use :
a) If we need a basic scatter plot, use plt.plot(), especially if we want to
prioritize performance.
b) If we want to customize our scatter plot by using more advanced plotting
features, use plt.scatter().
• Example: We can create a simple scatter plot in Python by passing x and y
values to plt.scatter():
# scatter_plotting.py
importmatplotlib.pyplot as plt
plt.style.use('fivethirtyeight')
x = [2, 4, 6, 6, 9, 2, 7, 2, 6, 1, 8, 4, 5, 9, 1, 2, 3, 7, 5, 8, 1, 3]
y = [7, 8, 2, 4, 6, 4, 9, 5, 9, 3, 6, 7, 2, 4, 6, 7, 1, 9, 4, 3, 6, 9]
plt.scatter(x, y)
plt.show()
Output:
 lOMoARcPSD|36553333

Creating Advanced Scatterplots

• Scatterplots are especially important for data science because they can show
data patterns that aren't obvious when viewed in other ways.
import matplotlib.pyplot as plt
x_axis1 =[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
y_axis1 =[5, 16, 34, 56, 32, 56, 32, 12, 76, 89]
x_axis2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
y_axis2 = [53, 6, 46, 36, 15, 64, 73, 25, 82, 9]
plt.title("Prices over 10 years")
plt.scatter(x_axis1, y_axis1, color = 'darkblue', marker='x', label="item 1")
plt.scatter(x_axis2, y_axis2, color='darkred', marker='x', label="item 2")
plt.xlabel("Time (years)")
plt.ylabel("Price (dollars)")
plt.grid(True)
plt.legend()
plt.show()
• The chart displays two data sets. We distinguish between them by the colour
of the marker.
Error bars are included in Matplotlib line plots and graphs. Error is the
difference between the calculated value and actual value.
 lOMoARcPSD|36553333

Visualizing Errors
• Error bars are included in Matplotlib line plots and graphs. Error is the
difference between the calculated value and actual value.
• Without error bars, bar graphs provide the perception that a measurable or
determined number is defined to a high level of efficiency. The method
matplotlib.pyplot.errorbar() draws y vs. x as planes and/or indicators with error
bars associated.
• Adding the error bar in Matplotlib, Python. It's very simple, we just have to
write the value of the error. We use the command:
plt.errorbar(x, y, yerr = 2,
capsize=3) Where:
x = The data of the X axis.
Y = The data of the Y axis.
yerr = The error value of the Y axis. Each point has its own error value.
xerr = The error value of the X axis.
capsize = The size of the lower and upper lines of the error bar
• A simple example, where we only plot one point. The error is the 10% on the
Y axis.
importmatplotlib.pyplot as plt
x=1
y = 20
y_error = 20*0.10 ## El 10% de error
plt.errorbar(x,y, yerr = y_error, capsize=3)
plt.show()
Output:
 lOMoARcPSD|36553333

• We plot using the command "plt.errorbar (...)", giving it the desired

characteristics.
Import matplotlib.pyplot as plt
Import numpy as np
x = np.arange(1,8)
y = np.array([20,10,45,32,38,21,27])
y_error = y * 0.10 ##El 10%
plt.errorbar(x, y, yerr =
y_error,
linestyle="None", fmt="ob", capsize=3, ecolor="k")
plt.show()
• Parameters of the errorbar :
a) yerr is the error value in each point.
b) linestyle, here it indicate that we will not plot a line.
c) fmt, is the type of marker, in this case is a point ("o") blue ("b").
d) capsize, is the size of the lower and upper lines of the error bar.
e) ecolor, is the color of the error bar. The default color is the marker color.
Output:
 lOMoARcPSD|36553333

• Multiple lines in Matplotlib Errorbar in Python : The ability to draw numerous

lines in almost the same plot is critical. We'll draw many errorbars in the same
graph by using this scheme.
Import numpy as np
Import matplotlib.pyplot as plt
fig = plt.figure()
x = np.arange(20)
y = 4* np.sin(x / 20 * np.pi)
yerr = np.linspace (0.06, 0.3, 20)
plt.errorbar(x, y + 8, yerr = yerr,
) plt.errorbar(x, y + 6, yerr =
yerr, uplims = True, )
plt.errorbar(x, y + 4, yerr =
yerr, uplims = True,
lolims True, )
upperlimits = [True, False] *
6 lowerlimits = [False, True]*
6 plt.errorbar(x, y, yerr = yerr,
 lOMoARcPSD|36553333

uplims =upperlimits,
lolims = lowerlimits, )
plt.legend(loc='upper left')
plt.title('Example')
plt.show()
Output:

It is useful to display three-dimensional data in two dimensions using contours

or color- coded regions.
Density and Contour Plots
• It is useful to display three-dimensional data in two dimensions using contours
or color- coded regions. Three Matplotlib functions are used for this purpose.
They are :
a) plt.contour for contour plots,
b) plt.contourf for filled contour plots,
c) plt.imshow for showing images.
1. Contour plot :
• A contour line or isoline of a function of two variables is a curve along which
the function has a constant value. It is a cross-section of the three-dimensional
graph of the function f(x, y) parallel to the x, y plane.
 lOMoARcPSD|36553333

• Contour lines are used e.g. in geography and meteorology. In cartography, a

contour line joins points of equal height above a given level, such as mean sea
level.
• We can also say in a more general way that a contour line of a function with
two variables is a curve which connects points with the same values.
import numpy as np
xlist = np.linspace(-3.0, 3.0, 3)
ylist = np.linspace(-3.0, 3.0, 4)
X, Y = np.meshgrid(xlist, ylist
print(xlist)
print(ylist)
print(X)
print(Y)
Output:

Changing the colours and the line style

Import matplotlib.pyplot as plt
plt.figure()
cp = plt.contour(X, Y, Z, colors='black', linestyles='dashed')
plt.clabel(cp, inline=True,
 lOMoARcPSD|36553333

fontsize=10)
plt.title('Contour Plot')
plt.xlabel('x (cm)’)
plt.ylabel('y (cm)')
plt.show()
Output:

• When creating a contour plot, we can also specify the color map. There are
different classes of color maps. Matplotlib gives the following guidance :
a) Sequential: Change in lightness and often saturation of color incrementally,
often using a single hue; should be used for representing information that has
ordering.
b) Diverging: Change in lightness and possibly saturation of two different
colors that meet in the middle at an unsaturated color; should be used when the
information being plotted has a critical middle value, such as topography or
when the data deviates around zero.
c) Cyclic : Change in lightness of two different colors that meet in the middle
and beginning/end at an unsaturated color; should be used for values that wrap
around at the endpoints, such as phase angle, wind direction, or time of day.
d) Qualitative: Often are miscellaneous colors; should be used to represent
information which does not have ordering or relationships.
 lOMoARcPSD|36553333

• This data has both positive and negative values, which zero representing a
node for the wave function. There are three important display options for
contour plots: the undisplaced shape key, the scale factor, and the contour scale.
a) The displaced shape option controls if and how the deformed model is shown
in comparison to the undeformed (original) geometry. The "Deformed shape
only" is the default and provides no basis for comparison.
b) The "Deformed shape with undeformed edge" option overlays the contour
plot on an outline of the original model.
c) The "Deformed shape with undeformed model" option overlays the contour
plot on the original finite element model.
In a histogram, the data are grouped into ranges (e.g. 10 - 19, 20 - 29) and then
plotted as connected bars.
Histogram
• In a histogram, the data are grouped into ranges (e.g. 10 - 19, 20 - 29) and then
plotted as connected bars. Each bar represents a range of data. The width of
each bar is proportional to the width of each category, and the height is
proportional to the frequency or percentage of that category.
• It provides a visual interpretation of numerical data by showing the number of
data points that fall within a specified range of values called "bins".
• Fig. 5.5.1 shows histogram.
 lOMoARcPSD|36553333

• Histograms can display a large amount of data and the frequency of the data
values. The median and distribution of the data can be determined by a
histogram. In addition, it can show any outliers or gaps in the data.
• Matplotlib provides a dedicated function to compute and display histograms:
plt.hist()
• Code for creating histogram with randomized
data : import numpy as np
import matplotlib.pyplot as plt
x = 40* np.random.randn(50000)
plt.hist(x, 20, range=(-50, 50), histtype='stepfilled',
align='mid', color='r', label="Test Data')
plt.legend()
plt.title(' Histogram')
plt.show()
 lOMoARcPSD|36553333

Plot legends give meaning to a visualization, assigning labels to the various plot
elements.
Legend
• Plot legends give meaning to a visualization, assigning labels to the various
plot elements. Legends are found in maps - describe the pictorial language or
symbology of the map. Legends are used in line graphs to explain the function
or the values underlying the different lines of the graph.
• Matplotlib has native support for legends. Legends can be placed in various
positions: A legend can be placed inside or outside the chart and the position
can be moved. The legend() method adds the legend to the plot.
• To place the legend inside, simply call
legend(): import matplotlib.pyplot as plt
import numpy as np

y = [2,4,6,8,10,12,14,16,18,20]
y2 = [10,11,12,13,14,15,16,17,18,19]
x = np.arange(10)
fig = plt.figure()
ax = plt.subplot(111)
ax.plot(x, y, label='$y = numbers')
ax.plot(x, y2, label='$y2 = other numbers')
plt.title('Legend inside')
ax.legend()
plt.show()
Output:
 lOMoARcPSD|36553333

• If we add a label to the plot function, the value will be used as the label in the
legend command. There is another argument that we can add to the legend
function: We can define the location of the legend inside of the axes plot with
the parameter "loc". If we add a label to the plot function, the values will be
used in the legend command:
frompolynomialsimportPolynomial
importnumpyasnp
importmatplotlib.pyplotasplt
p=Polynomial(-0.8,2.3,0.5,1,0.2)
p_der=p.derivative()
fig, ax=plt.subplots()
X=np.linspace (-2,3,50,
endpoint=True) F=p(X)
F_derivative=p_der(X)
ax.plot(X,F,label="p")
ax.plot(X,F_derivative,label="derivation of p")
ax.legend(loc='upper left')
Output:
 lOMoARcPSD|36553333

Matplotlib legend on bottom

Import matplotlib.pyplotasplt
Import numpyasnp
y1 = [2,4,6,8,10,12,14,16,18,20]
y2 = [10,11,12,13,14,15,16,17,18,19]
x = np.arange(10)
fig = plt.figure()
ax = plt.subplot(111)
ax.plot(x, y, label='$y = numbers')
ax.plot(x, y2, label='$y2= = other
numbers') plt.title('Legend inside')
ax.legend(loc='upper center', bbox_to_anchor=(0.5, -0.05), &nbsp;
shadow=True, ncol=2)
plt.show()
Output:
 lOMoARcPSD|36553333

Subplots mean groups of axes that can exist in a single matplotlib figure.
subplots() function in the matplotlib library, helps in creating multiple layouts
of subplots.
Subplots
• Subplots mean groups of axes that can exist in a single matplotlib figure.
subplots() function in the matplotlib library, helps in creating multiple layouts
of subplots. It provides control over all the individual plots that are created.
• subplots() without arguments returns a Figure and a single Axes. This is
actually the simplest and recommended way of creating a single Figure and
Axes.
fig, ax = plt.subplots()
ax.plot(x,y)
ax.set_title('A single
plot') Output:
 lOMoARcPSD|36553333

• There are 3 different ways (at least) to create plots (called axes) in matplotlib.
They are:plt.axes(), figure.add_axis() and plt.subplots()
• plt.axes(): The most basic method of creating an axes is to use the plt.axes
function. It takes optional argument for figure coordinate system. These
numbers represent [bottom, left, width, height] in the figure coordinate system,
which ranges from 0 at the bottom left of the figure to 1 at the top right of the
figure.
• Plot just one figure with (x,y) coordinates: plt.plot(x, y).
• By calling subplot(n,m,k), we subdidive the figure into n rows and m columns
and specify that plotting should be done on the subplot number k. Subplots are
numbered row by row, from left to right.
Import matplotlib.pyplotasplt
Import numpy asnp
From math import pi
plt.figure(figsize=(8,4)) # set dimensions of the figure
x=np.linspace (0,2*pi,100)
foriinrange(1,7):
plt.subplot(2,3,i)# create subplots on a grid with 2 rows and 3 columns
plt.xticks([])# set no ticks on x-axis
plt.yticks([])# set no ticks on y-axis
plt.plot(np.sin(x), np.cos(i*x))
 lOMoARcPSD|36553333

plt.title('subplot'+'(2,3,' + str(i)+')')
plt.show()
Output:

When drawing large and complex plots in Matplotlib, we need a way of

labelling certain portion or points of interest on the graph.
Text and Annotation
• When drawing large and complex plots in Matplotlib, we need a way of
labelling certain portion or points of interest on the graph. To do so, Matplotlib
provides us with the "Annotation" feature which allows us to plot arrows and
text labels on the graphs to give them more meaning.
• There are four important parameters that you must always use with annotate().
a) text: This defines the text label. Takes a string as a value.
b) xy: The place where you want your arrowhead to point to. In other words,
the place you want to annotate. This is a tuple containing two values, x and y.
c) xytext: The coordinates for where you want to text to display.
d) arrowprops: A dictionary of key-value pairs which define various properties
for the arrow, such as color, size and arrowhead type.
Example :
Import matplotlib.pyplot as plt
Import numpy as np
fig, ax = plt.subplots()
 lOMoARcPSD|36553333

x = np.arange(0.0, 5.0, 0.01)

y =np.sin(2* np.pi *x)
# Annotation
ax.annotate('Local Max',
xy = (3.3, 1),
xytext (3, 1.8),
arrowprops = dict(facecolor = 'green',
shrink =0.05))
ax.set_ylim(-2, 2)
plt.plot(x, y)
plt.show()
Output:

Example :
Import plotly.graph_objectsasgo
fig=go.Figure()
fig.add_trace(go.Scatter( x=[0,1
,2,3,4,5,6,7,8],
 lOMoARcPSD|36553333

y=[0,1,3,2,4,3,4,6,5]
))
fig.add_trace(go.Scatter( x=[0,
1,2,3,4,5,6,7,8],
y=[0,4,5,1,2,2,3,4,2]
))
fig.add_annotation(x=2,y=5,
text="Text annotation with
arrow", showarrow=True,
arrowhead=1)
fig.add_annotation(x=4,y=4,
text="Text annotation without
arrow", showarrow=False,
yshift = 10)
fig.update_layout(showlegend=False)
fig.show()
Output:

A tick is a short line on an axis. For category axes, ticks separate each category.
Customization
 lOMoARcPSD|36553333

• A tick is a short line on an axis. For category axes, ticks separate each
category. For value axes, ticks mark the major divisions and show the exact
point on an axis that the axis label defines. Ticks are always the same color and
line style as the axis.
• Ticks are the markers denoting data points on axes. Matplotlib's default tick
locators and formatters are designed to be generally sufficient in many common
situations. Position and labels of ticks can be explicitly mentioned to suit
specific requirements.
• Fig. 5.9.1 shows ticks.

• Ticks come in two types: major and minor.

a) Major ticks separate the axis into major units. On category axes, major ticks
are the only ticks available. On value axes, one major tick appears for every
major axis division.
b) Minor ticks subdivide the major tick units. They can only appear on value
axes. One minor tick appears for every minor axis division.
• By default, major ticks appear for value axes. xticks is a method, which can be
used to get or to set the current tick locations and the labels.
• The following program creates a plot with both major and minor tick marks,
customized to be thicker and wider than the default, with the major tick marks
point into and out of the plot area.
Import numpyasnp
Import matplotlib.pyplot as plt
# A selection of functions on rnabcissa points for 0 <= x < 1
 lOMoARcPSD|36553333

rn=100
rx=np.linspace(0,1,rn, endpoint=False)
deftophat(rx):
"""Top hat function: y = 1 for x < 0.5, y=0 for x >= 0.5"""
ry=np.ones(rn)
ry[rx>=0.5]=0
returnry
# A dictionary of functions to choose
from ry={half-
sawtooth':lambdarx:rx.copy(), 'top-
hat':tophat,
'sawtooth':lambdarx:2*np.abs(rx-0.5)}
# Repeat the chosen function nrep times
nrep=4
x=np.linspace (0,nrep,nrep*rn,
endpoint=False) y=np.tile(ry['top-hat'] (rx),
nrep) fig=plt.figure()
ax=fig.add_subplot(111)
ax.plot(x,y,'k',lw=2)
# Add a bit of padding around the plotted line to aid
visualization ax.set_ylim(-0.1,1.1)
ax.set_xlim(x[0]-0.5,x[-1]+0.5)
# Customize the tick marks and turn the grid on
ax.minorticks_on()
ax.tick_params (which='major',length=10, width=2,direction='inout')
ax.tick_params(which='minor',length=5,width=2, direction='in')
ax.grid(which='both')
plt.show()
 lOMoARcPSD|36553333

Output:

Matplotlib is the most popular choice for data visualization. While initially
developed for plotting 2-D charts like histograms, bar charts, scatter plots, line
plots, etc.,
Three Dimensional Plotting
• Matplotlib is the most popular choice for data visualization. While initially
developed for plotting 2-D charts like histograms, bar charts, scatter plots, line
plots, etc., Matplotlib has extended its capabilities to offer 3D plotting modules
as well.
• First import the library :
importmatplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
• The first one is a standard import statement for plotting using matplotlib,
which you would see for 2D plotting as well. The second import of the Axes3D
class is required for enabling 3D projections. It is, otherwise, not used anywhere
else.
• Create figure and axes
fig = plt.figure(figsize=(4,4))
ax = fig.add_subplot(111, projection='3d')
Output:
 lOMoARcPSD|36553333

Example :
fig=plt.figure(figsize=(8,8))
ax=plt.axes(projection='3d')
ax.grid()
t=np.arange(0,10*np.pi,np.pi/50)
x=np.sin(t)
y=np.cos(t)
ax.plot3D(x,y,t)
ax.set_title('3D Parametric Plot')
# Set axes label
ax.set_xlabel('x',labelpad=20)
ax.set_ylabel('y', labelpad=20)
ax.set_zlabel('t', labelpad=20)
plt.show()
Output:
 lOMoARcPSD|36553333

Basemap is a toolkit under the Python visualization library Matplotlib. Its main
function is to draw 2D maps, which are important for visualizing spatial data.
Geographic Data with Basemap
• Basemap is a toolkit under the Python visualization library Matplotlib. Its
main function is to draw 2D maps, which are important for visualizing spatial
data. Basemap itself does not do any plotting, but provides the ability to
transform coordinates into one of 25 different map projections.
• Matplotlib can also be used to plot contours, images, vectors, lines or points in
transformed coordinates. Basemap includes the GSSH coastline dataset, as well
as datasets from GMT for rivers, states and national boundaries.
• These datasets can be used to plot coastlines, rivers and political boundaries on
a map at several different resolutions. Basemap uses the Geometry Engine-
Open Source (GEOS) library at the bottom to clip coastline and boundary
features to the desired map projection area. In addition, basemap provides
the ability to read shapefiles.
• Basemap cannot be installed using pip install basemap. If Anaconda is
installed, you can install basemap using canda install basemap.
• Example objects in basemap:
a) contour(): Draw contour lines.
b) contourf(): Draw filled contours.
c) imshow(): Draw an image.
d) pcolor(): Draw a pseudocolor plot.
e) pcolormesh(): Draw a pseudocolor plot (faster version for regular meshes).
f) plot(): Draw lines and/or markers.
 lOMoARcPSD|36553333

g) scatter(): Draw points with markers.

h) quiver(): Draw vectors.(draw vector map, 3D is surface map)
i) barbs(): Draw wind barbs (draw wind plume map)
j) drawgreatcircle(): Draw a great circle (draws a great circle route)
• For example, if we wanted to show all the different types of endangered plants
within a region, we would use a base map showing roads, provincial and state
boundaries, waterways and elevation. Onto this base map, we could add layers
that show the location of different categories of endangered plants. One added
layer could be trees, another layer could be mosses and lichens, another layer
could be grasses.
Basemap basic usage:
import warnings
warnings.filterwarmings('ignore')
frommpl_toolkits.basemap import Basemap
importmatplotlib.pyplot as plt
map = Basemap()
map.drawcoastlines()
# plt.show()
plt.savefig('test.png')
Output:
 lOMoARcPSD|36553333

Seaborn is a Python data visualization library based on Matplotlib. It provides a

high-level interface for drawing attractive and informative statistical graphics.
Visualization with Seaborn
• Seaborn is a Python data visualization library based on Matplotlib. It provides
a high-level interface for drawing attractive and informative statistical graphics.
Seaborn is an open- source Python library.
• Seaborn helps you explore and understand your data. Its plotting functions
operate on dataframes and arrays containing whole datasets and internally
perform the necessary semantic mapping and statistical aggregation to produce
informative plots.
• Its dataset-oriented, declarative API. User should focus on what the different
elements of your plots mean, rather than on the details of how to draw them.
• Keys features:
a) Seaborn is a statistical plotting library
b) It has beautiful default styles
c) It also is designed to work very well with Pandas dataframe objects.
Seaborn works easily with dataframes and the Pandas library. The graphs
created can also be customized easily.
• Functionality that seaborn offers:
a) A dataset-oriented API for examining relationships between multiple
variables
b) Convenient views onto the overall structure of complex datasets
c) Specialized support for using categorical variables to show observations or
aggregate statistics
d) Options for visualizing univariate or bivariate distributions and for
comparing them between subsets of data
e) Automatic estimation and plotting of linear regression models for different
kinds of dependent variables
f) High-level abstractions for structuring multi-plot grids that let you easily
build complex visualizations
g) Concise control over matplotlib figure styling with several built-in themes
 lOMoARcPSD|36553333

h) Tools for choosing color palettes that faithfully reveal patterns in your data.
Plot a Scatter Plot in Seaborn:
Import matplotlib.pyplot as plt
Import seaborn as sns
import pandas as pd
df = pd.read_csv('worldHappiness2016.csv').
sns.scatterplot(data= df, x = "Economy (GDP per Capita)", y =
plt.show()
Output:

Difference between Matplotlib and Seaborn

 lOMoARcPSD|36553333

Data visualization is the graphical representation of information and data.

Two Marks Questions with Answers
Q.1What is data visualization?
Ans: Data visualization is the graphical representation of information and data.
Q.2 Which concept is used in data
visualization? Ans: Data visualization based on
two concepts:
1. Each attribute of training data is visualized in a separate part of screen.
2. Different class labels of training objects are represented by different
colors.
Q.3 List the benefits of data visualization.
Ans.: • Constructing ways in absorbing information. Data visualization enables
users to receive vast amounts of information regarding operational and business
conditions.
• Visualize relationships and patterns in businesses.
• More collaboration and sharing of information.
• More self-service functions for the end users.
Q.4 Why big data visualization is
important? Ans. Reasons:
• It provides clear knowledge about patterns of data.
 lOMoARcPSD|36553333

• Detects hidden structures in data.

• Identify areas that need to be improved.
• Help us to understand which products to place where.
• Clarify factors which influence human behaviour.
Q.5 Explain Matplotlib.
Ans. Matplotlib is a cross-platform, data visualization and graphical plotting
library for Python and its numerical extension NumPy. Matplotlib is a
comprehensive library for creating static, animated and interactive
visualizations in Python. Matplotlib is a plotting library for the Python
programming language. It allows to make quality charts in few lines of code.
Most of the other python plotting library are build on top of Matplotlib.
Q.6 What is contour plot ?
Ans. A contour line or isoline of a function of two variables is a curve along
which the function has a constant value. It is a cross-section of the three-
dimensional graph of the function f(x, y) parallel to the x, y plane. Contour lines
are used e.g. in geography and meteorology. In cartography, a contour line joins
points of equal height above a given level, such as mean sea level.
Q.7 Explain legends.
Ans. Plot legends give meaning to a visualization, assigning labels to the
various plot elements. Legends are found in maps describe the pictorial
language or symbology of the map. Legends are used in line graphs to explain
the function or the values underlying the different lines of the graph.
Q.8 What is subplots?
Ans. Subplots mean groups of axes that can exist in a single matplotlib figure.
subplots() function in the matplotlib library, helps in creating multiple layouts
of subplots. It provides control over all the individual plots that are created.
Q.9 What is use of tick?
Ans. A tick is a short line on an axis. For category axes, ticks separate each
category. For value axes, ticks mark the major divisions and show the exact
point on an axis that the axis label defines. Ticks are always the same color and
line style as the axis.
• Ticks are the markers denoting data points on axes. Matplotlib's default tick
locators and formatters are designed to be generally sufficient in many common
 lOMoARcPSD|36553333

situations. Position and labels of ticks can be explicitly mentioned to suit

specific requirements.
Q.10 Describe in short Basemap.
Ans. • Basemap is a toolkit under the Python visualization library Matplotlib.
Its main function is to draw 2D maps, which are important for visualizing
spatial data. Basemap itself does not do any plotting, but provides the ability to
transform coordinates into one of 25 different map projections.
• Matplotlib can also be used to plot contours, images, vectors, lines or points
in transformed coordinates. Basemap includes the GSSH coastline dataset, as
well as datasets from GMT for rivers, states and national boundaries.
Q.11 What is Seaborn?
Ans. : • Seaborn is a Python data visualization library based on Matplotlib. It
provides a high-level interface for drawing attractive and informative statistical
graphics. Seaborn is an opensource Python library.
• Its dataset-oriented, declarative API. User should focus on what the different
elements of your plots mean, rather than on the details of how to draw them.