Seaborn Library for Data Visualization in Python

Seaborn Library for Data Visualization in Python, welcome to the world of  Python data visualization using seaborn. Are you the one who is looking forward to knowing the Seaborn Library for Data Visualization in Python? Or the one who is very keen to explore the Seaborn Library for Data Visualization in Python with examples that are available? Then you’ve landed on the Right path which provides the standard information of Python Programming language.

Seaborn library is a data visualization library based on matplotlib in Python. It provides a high-level interface for drawing attractive and informative statistical graphics.Do you want to know about data visualization in python using seaborn, then just follow the below mentioned Python Data Visualisation using Seaborn tutorial for Beginners from Prwatech and take advanced Python training like a Pro from today itself under 10+ years of hands-on experienced Professionals.

Python Data Visualisation using Seaborn

1. In the world of Analytics, the best way to get insight details is by visualizing the dataset.
2. Datasets can be visualized by displaying it as plots that are easy to understand and explore. Such data helps in drawing the attention of key elements.
3. In order to analyze a set of data using Python, we use Matplotlib, a widely implemented 2D plotting library.
4. Similarly, Seaborn is a visualization library in Python.
5. It is built on top of Matplotlib.

Difference between Matplotlib and Seaborn

Seaborn helps resolve the two major problems faced by Matplotlib; the problems are

1. Default Matplotlib parameters
2. Working with data frames
3. As Seaborn compliments and extends Matplotlib, the learning curve is quite gradual. If you know Matplotlib, you are already halfway through Seaborn.

Important Features of Seaborn

Seaborn is built over Python’s core visualization library Matplotlib. It is used to serve as a compliment and not a replacement. Although, Seaborn comes with some very important features. 

Let us see a few of them here. The features helps in

1. It is a built-in theme for styling matplotlib graphics

2. Visualizing univariate and bivariate data

3. Fitting in and visualizing linear regression models

4. Plotting statistical time-series data

5. Seaborn works better with NumPy and Pandas data structures

6. In most cases, you will still use Matplotlib for simple plotting. The knowledge of Matplotlib is recommended to use Seaborn’s default plots.

7. Installing Seaborn and getting started

8. Using Pip Installer

Installation of Seaborn

To install the latest release of Seaborn, you can use pip:

Syntax) pip install seaborn

For Windows, Linux & Mac using Anaconda

Dependencies

1.Python 2.7 or 3.4+

2. numpy

3. scipy

4. pandas

5. matplotlib

Importing Libraries

 1. import pandas as pd

2. from matplotlib import pyplot as plt

3. import seaborn as sb

Importing Datasets

 1. Seaborn comes with a few important datasets in its library. 

2. When Seaborn is installed, datasets download automatically.

3. Loading DataSet:

4. load_dataset()

Importing Data as Pandas DataFrame

 1. import seaborn as sb

2. df = sb.load_dataset(‘tickets’)

3. print df.head()

Seaborn – Figure Aesthetic

 1. Aesthetics is a set of principles concerned with nature and appreciation of beauty, especially in art. Visualization is an art of representing data in an effective and easiest possible way.

2. Seaborn comes with customized themes and a high-level interface to customize and control the look of Matplotlib graphs.

import numpy as np
from matplotlib import pyplot as plt
def sinplot(flip = 1):
x = np.linspace(0, 4, 400)
for i in range(1, 4):

plt.plot(x, np.sin(x + i * .6) * (8 – i) * flip)
sinplot()
plt.show()

Output()

Using set() functions

import numpy as np
from matplotlib import pyplot as plt
def sinplot(flip = 1):
x = np.linspace(0, 4, 400)
for i in range(1, 4):
plt.plot(x, np.sin(x + i * .6) * (8 – i) * flip)
import seaborn as sb
sb.set()
sinplot()
plt.show()

Output:

The above two figures show the difference in default Matplotlib and Seaborn plots. The representation of the dataset is the same, but the representation style differs in both.

Basically, Seaborn splits the Matplotlib parameters into two groups−

 1. Plot styles

2. Plot scale

Seaborn Figure Styles

 1. The interface to manipulate the styles is set_style(). 

2. Using this function you can set the theme of the plot. 

3. As per the latest updated version, below are five themes available.

    Darkgrid

    Whitegrid

    Dark

    White

    Ticks

    Using Darkgrip

import numpy as np
from matplotlib import pyplot as plt
def sinplot(flip=1):
x = np.linspace(0, 4, 400)
for i in range(1, 4):
plt.plot(x, np.sin(x + i * .6) * (8 – i) * flip)
import seaborn as sb
sb.set_style(“darkgrid”)
sinplot()
plt.show()

Overriding the Elements

 1. If you need to customize the Seaborn styles, you can pass a dictionary of parameters to set_style() function. 

2. Parameters available are viewed using axes_style() function

Scaling Plot Elements

We also have control of plot elements and can control the scale of the plot using set_context() function. 

We have four preset templates for contexts, based on relative size, the contexts are named as follows

 1. Paper

2. Notebook

3. Talk

4. Poster

By default, context is set to notebook; and was used in the plots above.

Seaborn – Color Palette

 1. Color plays an indeed important role than any other aspect when it comes to visualizations. 

2. When used effectively, color can add more value to a plot. 

3. A palette is a flat surface on which a painter arranges and mixes paints together.

Building Color Palette:

 1. Seaborn has a function called color_palette(), which is used to give colors to plots and adding more aesthetic value to it.

2. Syntax) seaborn.color_palette(palette = None, n_colors = None, desat = No

Parameter

Return

Return refers to the list of RGB tuples. Following are the readily available Seaborn palettes:

 1. Deep

 2.Muted

3. Bright

4. Pastel

5. Dark

6. Colorblind

It is difficult to decide which palette should be used for a given data set without actually knowing the characteristics of data. Being aware of it, we will classify the different ways of using color_palette() types:

 1. qualitative

2. sequential

3. diverging

We have a function seaborn.palplot() which deals with color palettes.

It plots the color palette as a horizontal array.

Qualitative or categorical palettes are best suitable to plot the categorical data.

from matplotlib import pyplot as plt
import seaborn as sb
current_palette = sb.color_palette()
sb.palplot(current_palette)
plt.show()

Sequential Color Palettes

The sequential plot is suitable to express the distribution of data ranging from relatively lower values to higher values within a range.

Appending an additional character ‘s’ to the color passed to the color parameter will plot the Sequential plot.

from matplotlib import pyplot as plt
import seaborn as sb
current_palette = sb.color_palette()
sb.palplot(sb.color_palette(“Reds”))
plt.show()

Output()

Diverging Color Palette

 1. Diverging palettes uses two different colors. 

2. Each color represents variation in value ranging from common points in either direction.

3. Assume plotting data ranging from -2 to 2. The values from -2 to 0 will take one color and 0 to +1 will take another color.

4. By default, the values are centered from 0. You can control it with parameter center by passing a value.

from matplotlib import pyplot as plt
import seaborn as sb
current_palette = sb.color_palette()
sb.palplot(sb.color_palette(“BrBG”, 9))
plt.show()

Setting the Default Color Palette

 1. The functions color_palette() have a companion called set_palette().

2. The relationship between them is similar to pairs covered in the aesthetics chapter. 

3. The arguments are same for both set_palette() and color_palette(), but the default Matplotlib parameters changed so that the palette is used for all plots.

import numpy as np
from matplotlib import pyplot as plt
def sinplot(flip = 1):
x = np.linspace(0, 4, 400)
for i in range(1, 4):
plt.plot(x, np.sin(x + i * .6) * (8 – i) * flip)

import seaborn as sb
sb.set_style(“white”)
sb.set_palette(“husl”)
sinplot()
plt.show()

Plotting Univariate Distribution

The distribution of data is the foremost thing that we are supposed to understand while analyzing the data. Here, we will see how seaborn helps us in understanding the univariate distribution of the data.

Syntax) seaborn.distplot()

Parameters:

Seaborn – Histogram

Histograms represent data distribution by forming bins along with the range of the data and then drawing bars to show the number of observations that fall in each bin.
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘iris’)
sb.distplot(df[‘petal_length’],kde = False)
plt.show()

Here, kde flag is set as False. Therefore, the representation of the kernel estimation plot is removed and the only histogram is plotted.

Kernel Density Estimates

Kernel Density Estimation (KDE) is used to estimate the probability density function (PDF) of a continuous random variable. It is used in the non-parametric analysis.

Setting up the hist flag to False value in a distplot will yield the kernel density estimation plot.

Ex) import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘iris’)
sb.distplot(df[‘petal_length’],hist=False)
plt.show()

OutPut()

Fitting Parametric Distribution

distplot() is used to visualize the parametric distribution of a dataset.

Ex) import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘iris’)
sb.distplot(df[‘petal_length’])
plt.show()

Output()

Plotting Bivariate Distribution

Bivariate Distribution is used to identify the relation between the two variables. This mainly deals with how one variable is behaving with respect to the other.

The best way to analyze Bivariate Distribution in seaborn is by using a jointplot() function.

Jointplot creates a multi-panel figure which projects bivariate relationship between two variables and univariate distribution of each variable on separate axes.

Scatter Plot

Scatter plot is most convenient way to display distribution where each observation is represented in a two-dimensional plot via x and y axis.

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘iris’)
sb.jointplot(x = ‘petal_length’,y = ‘petal_width’,data = df)
plt.show()

A trend in the plot displays a positive correlation exists between variables under study.

Hexbin Plot

Hexagonal binning is used in a bivariate data analysis when the dataset is sparse in density, which means when data is very scattered and difficult to analyze through scatterplots.

An addition parameter called ‘kind’ and value ‘hex’ plots a hexbin plot.

Ex) import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘iris’)
sb.jointplot(x = ‘petal_length’,y = ‘petal_width’,data = df,kind = ‘hex’)
plt.show()

Output()

Seaborn – Visualizing Pairwise Relationship

Data under real-time study contain many variables. In such cases, the relation between each and every variable should be analyzed. Plotting Bivariate Distribution of (n,2) combinations will be a very complicated and time taking process.

In order to plot multiple pairwise bivariate distributions in a dataset, you may use the pairplot() function. 

This shows the relationship for (n,2) a combination of the variable in a DataFrame as a matrix of plots and diagonal plots are the univariate plots.

Parameters

Ex: import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘iris’)
sb.set_style(“ticks”)
sb.pairplot(df,hue = ‘species’,diag_kind = “kde”,kind = “scatter”,palette = “husl”)
plt.show()

Output()

Seaborn – Plotting Categorical Data

Scatter plots are not suitable when the variable under study is categorical.

When one or both variables under study are categorical, we use plots like striplot(), swarmplot(), etc, Seaborn provides an interface to do so.

Categorical Scatter Plots:

stripplot()

stripplot() is used when one of the variables under study is categorical. It presents the data in sorted order along any one of the axis.

import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘iris’)
sb.stripplot(x = “species”, y = “petal_length”, data = df)
plt.show()

In the above graph, we can clearly view the difference of petal_length in each species. But, the major issue with the above scatter plot is that points on the scatter plot are overlapped. We use the ‘Jitter’ parameter to handle this kind of scenario.

import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘iris’)
sb.stripplot(x = “species”, y = “petal_length”, data = df, jitter = True)
plt.show()

Swarmplot()

Another option which we can use as an alternative to ‘Jitter’ is a function swarmplot(). 

This function places each point of scatter plot over categorical axis and hence avoids overlapping points.

import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘iris’)
sb.swarmplot(x = “species”, y = “petal_length”, data = df)
plt.show()

Seaborn – Distribution of Observations

In categorical scatter plots the approach becomes limited in the information, it can provide about the distribution of values within each category. Now, going further, let’s see what facilitates us with the comparison within categories.

Box Plots

Boxplot is convenient to visualize the distribution of data through their quartiles.

Box plots normally have vertical lines extending from the boxes which are termed as whiskers. These whiskers denote variability outside the upper and lower quartiles, therefore Box Plots are also termed as box-and-whisker plot and box-and-whisker diagram. Any Outliers in data are plotted as individual points.

import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘iris’)
sb.boxplot(x = “species”, y = “petal_length”, data = df)
plt.show()

Violin Plots

Violin Plots are a combination of both box plot with the kernel density estimates. So, these plots are easier to analyze and understand the distribution of the data.

import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘tips’)
sb.violinplot(x = “day”, y = “total_bill”, data=df)
plt.show()

The quartile and whisker values from the boxplot are shown in the violin. As the violin plot uses KDE, the wider portion of the violin denotes higher density and the narrow region represents relatively lower density. The Inter-Quartile range in boxplot and higher density portion in kde lie in the same region of each category of the violin plot.

The above plot displays distribution of total_bill on four days of the week. But, in addition to that, if we want to see how distribution behaves with respect to sex, let’s explore it:

import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘tips’)
sb.violinplot(x = “day”, y = “total_bill”,hue = ‘sex’, data = df)
plt.show()

Now from the above, we can clearly visualize spending behavior between males and females. We can easily tell that; a man makes more bills than a woman by looking at the graph.

Seaborn – Statistical Estimation

In most of the scenarios, we deal with predictions of the whole distribution of the data. But when it comes to central tendency predictions, we require a specific way to summarize the distribution. Mean and median are the very regularly used techniques to predict the central tendency of the distribution.

In all the plots that we learned until now, we made the visualization of the whole distribution. Now, let us discuss the plots with which we can predict the central tendency of the distribution.

Bar Plot

The barplot() displays the relationship between a categorical variable and a continuous variable. The dataset is represented in rectangular bars where length the bar represents the proportion of the dataset in that category.

The bar plot indicates the estimate of central tendency. Let us use the ‘titanic’ dataset to learn bar plots.

import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘titanic’)
sb.barplot(x = “sex”, y = “survived”, hue = “class”, data = df)
plt.show()

In this example, we can view the average quantity of survivals of males and females in each class. From the graph we can understand, more quantity of females survived than males. In both males and females, more quantity of survival is from the first class.

A special case in barplot is to visualize the no of observations in each category instead of computing a statistic for a second variable. For this, we use countplot().

import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘titanic’)
sb.countplot(x =” class “, data = df, palette = “Blues”);
plt.show()

Plot clarifies that, number of passengers in third class are higher than first and second class.

Point Plots

Point plots are the same as bar plots but in a different style. Instead of the full bar, the value of the prediction is represented by the point at a certain height on the other axis.

import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘titanic’)
sb.pointplot(x = “sex”, y = “survived”, hue = “class”, data = df)
plt.show()

Seaborn – Plotting Wide Form Data

It is always preferred to use ‘long-from’ or ‘tidy’ datasets. But at times when we are left with no option other than to use a ‘wide-form’ dataset, same functions can also be implemented to “wide-form” data in a variety of formats, including Pandas Data Frames or two-dimensional NumPy arrays. These objects must be passed directly to the dataset parameter the x and y variables must be specified as strings

import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘iris’)
sb.boxplot(data = df, orient = “h”)
plt.show()

Seaborn – Multi Panel Categorical Plots

Categorical data can we displayed using two plots, you can either use the functions pointplot(), or the higher-level function factorplot().

Factorplot()

Factorplot plots a categorical plot on a FacetGrid. Using ‘kind’ parameter we can choose the plots like boxplot, violinplot, barplot and stripplot. FacetGrid uses pointplot by default.

import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘exercise’)
sb.factorplot(x = “time”, y = “pulse”, hue = “kind”,data = df);
plt.show()

We can use different plot to display same data using the kind parameter

import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘exercise’)
sb.factorplot(x = “time”, y = “pulse”, hue = “kind”, kind = ‘violin’,data = df);
plt.show()

What is Facet Grid?

Facet grid forms a matrix of panels defined by rows and columns by dividing the variables. Due to panels, a single plot looks like multiple plots. It is very helpful to analyze all combinations in 2 discrete variables.

import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘exercise’)
sb.factorplot(x = “time”, y = “pulse”, hue = “kind”, kind = ‘violin’, col = “diet”, data = df);
plt.show()

The facility of using Facet is, we can input another variable into the graph. The above graph is divided into two plots based on a third variable called ‘diet’ using the ‘col’ parameter.

We can make many column facets and align them with the rows of the grid:

import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘titanic’)
sb.factorplot(“alive”, col = “deck”, col_wrap = 3,data = df[df.deck.notnull()],kind = “count”)
plt.show()

Mostly, we use data that contain multiple quantitative variables, and the goal of an analysis is to relate those variables to each other. This can be done by regression lines.

While building regression models, we normally check for multicollinearity, where we need to visualize the correlation between all the combinations of continuous variables and will take the required action to remove multicollinearity if exists. In such cases, the following techniques help.

Functions to Draw Linear Regression Models

There are two main functions in Seaborn to visualize a linear relationship identified through regression. 

They are regplot() and lmplot().

regplot	lmplot
accepts the x and y variables in a variety of formats includes simple numpy arrays, pandas Series objects, or as references to variables in a pandas DataFrame	has a dataset as a required parameter and the x and y variables must be specified as strings. This data format is called “long-form” data
import seaborn as sb from matplotlib import pyplot as plt df = sb.load_dataset(‘tips’) sb.regplot(x = “total_bill”, y = “tip”, data = df) plt.show()	import seaborn as sb from matplotlib import pyplot as plt df = sb.load_dataset(‘tips’) sb.lmplot(x = “total_bill”, y = “tip”, data = df) plt.show()

We can also fit a linear regression when one of the variables takes discrete values

import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘tips’)
sb.lmplot(x = “size”, y = “tip”, data = df)
plt.show()

Fitting Different Kinds of Models

In most of the cases, the dataset is non-linear and the above methods cannot generalize the regression line.

Let us use Anscombe’s dataset with the regression plots:

import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘anscombe’)
sb.lmplot(x = “x”, y = “y”, data = df.query(“dataset == ‘II'”))
plt.show()

The plot displays the high deviation of data points from a regression line. These non-linear, higher order can be visualized using the lmplot() and regplot().These can fit a polynomial regression model to explore simple kinds of nonlinear trends in the datasets :

import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘anscombe’)
sb.lmplot(x = “x”, y = “y”, data = df.query(“dataset == ‘II'”),order = 2)
plt.show()

Seaborn – Facet Grid

A useful approach to understand medium-dimensional data is by drawing multiple instances of the same plot over different subsets of your dataset.

This technique is normally known as “lattice”, or “trellis” plotting, and it is related to the idea of “small multiples”.

To use these features, your data has to be in a Pandas DataFrame.

Plotting Small Multiples of Data Subsets

We have already seen the FacetGrid example where FacetGrid class helps in displaying the distribution of one variable as well as the relationship between multiple variables separately within subsets of your dataset using multiple panels.

A FacetGrid could be drawn with up to three dimensions − rows, cols, and hue. The first 2 have obvious correspondence with the resulting array of axes; think of the hue variable as the third dimension along a depth axis, where different levels are graphed with different colors.

FacetGrid object takes a data frame as input and the names of variables that will form a row, column, or hue dimensions of the grid.

Variables must be categorical and data at each level of the variable will be used for a facet along that axis.

import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘tips’)
g = sb.FacetGrid(df, col = “time”)
plt.show()

Here we have just initialized the facet grid object which doesn’t draw anything over them.

The main approach for displaying data over this grid is with the FacetGrid.map() method. Let’s visualize the distribution of tips in each of these subsets, using a histogram.

import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘tips’)
g = sb.FacetGrid(df, col = “time”)
g.map(plt.hist, “tip”)
plt.show()

The no of plots is more than one because of the parameter col.

To make a relational plot, pass the multiple variable names.

import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘tips’)
g = sb.FacetGrid(df, col = “sex”, hue = “smoker”)
g.map(plt.scatter, “total_bill”, “tip”)
plt.show()

Seaborn – Pair Grid

PairGrid allows us to plot a grid of subplots using same plot type to visualize a dataset.

Unlike FacetGrid, it uses a different pair of variables for every subplot. It creates a matrix of sub-plots. It is also called a “scatterplot matrix”.

The usage of pairgrid is similar to facetgrid. First initialise the grid and then pass plotting function.

import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘iris’)
g = sb.PairGrid(df)
g.map(plt.scatter);
plt.show()

It is also possible to plot different functions on the diagonal to show the univariate distribution of variable in each column.

import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘iris’)
g = sb.PairGrid(df)
g.map_diag(plt.hist)
g.map_offdiag(plt.scatter);
plt.show()

We can use different functions in the upper and lower triangles to view different aspects of relationship.

import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset(‘iris’)
g = sb.PairGrid(df)
g.map_upper(plt.scatter)
g.map_lower(sb.kdeplot, cmap = “Blues_d”)
g.map_diag(sb.kdeplot, lw = 3, legend = False);
plt.show()

We hope you understand sets in Python Data Visualisation using Seaborn concepts.Get success in your career as a Python developer by being a part of the Prwatech, India’s leading Python training institute in Bangalore.