Introduction to Data Visualization in Python

Get commenced visualizing facts in Python the usage of Matplotlib, Pandas and Seaborn

Data visualization is the discipline of seeking to understand information via placing it in a visual context so that styles, tendencies, and correlations that might not otherwise be detected may be uncovered.

Python offers more than one splendid graphing libraries full of plenty of different capabilities. Whether you need to create interactive or rather customized plots, Python has an terrific library for you.

To get a touch evaluate, right here are some popular plotting libraries:

• Matplotlib: low degree, gives lots of freedom
• Pandas Visualization: clean to apply interface, constructed on Matplotlib
• Seaborn: high-stage interface, fantastic default styles
• plotnine: based totally on R’s ggplot2, uses Grammar of Graphics
• Plotly: can create interactive plots

In this text, we are able to learn how to create fundamental plots using Matplotlib, Pandas visualization, and Seaborn in addition to a way to use some precise functions of each library. This article will attention at the syntax and no longer on interpreting the graphs, which I will cover in some other weblog submit.

In similarly articles, I will go over interactive plotting equipment like Plotly, that's constructed on D3 and also can be used with JavaScript.

Importing Datasets

In this text, we can use  freely to be had datasets. The Iris and Wine Reviews dataset, which we are able to each load into memory the use of pandas read_csv approach.

import pandas as pd
iris = pd.read_csv('iris.csv', names=['sepal_length', 'sepal_width', 'petal_length', 'petal_width', 'class'])
print(iris.head())

wine_reviews = pd.read_csv('winemag-data-130k-v2.csv', index_col=0)
wine_reviews.head()

Matplotlib

Matplotlib is the maximum popular Python plotting library. It is a low-stage library with a Matlab-like interface that offers masses of freedom at the price of getting to write down more code.

To set up Matplotlib, pip, and conda may be used.

pip install matplotlib
or
conda install matplotlib

Matplotlib is mainly appropriate for growing simple graphs like line charts, bar charts, histograms, and so forth. It may be imported via typing:

import matplotlib.pyplot as plt

Scatter Plot

To create a scatter plot in Matplotlib, we can use the scatter approach. We may even create a figure and an axis the use of plt.Subplots to provide our plot a identify and labels.

# create a figure and axis
fig, ax = plt.subplots()

# scatter the sepal_length against the sepal_width
ax.scatter(iris['sepal_length'], iris['sepal_width'])
# set a title and labels
ax.set_title('Iris Dataset')
ax.set_xlabel('sepal_length')
ax.set_ylabel('sepal_width')

We can provide the graph extra that means by way of coloring every facts factor by way of its magnificence. This can be finished by developing a dictionary that maps from class to coloration and then scattering each point on its own the use of a for-loop and passing the respective shade.

# create color dictionary
colors = {'Iris-setosa':'r', 'Iris-versicolor':'g', 'Iris-virginica':'b'}
# create a figure and axis
fig, ax = plt.subplots()
# plot each data-point
for i in range(len(iris['sepal_length'])):
    ax.scatter(iris['sepal_length'][i], iris['sepal_width'][i],color=colors[iris['class'][i]])
# set a title and labels
ax.set_title('Iris Dataset')
ax.set_xlabel('sepal_length')
ax.set_ylabel('sepal_width')

Line Chart

In Matplotlib, we are able to create a line chart through calling the plot technique. We can also plot more than one columns in a single graph by looping thru the columns we need and plotting every column on the same axis.

# get columns to plot
columns = iris.columns.drop(['class'])
# create x data
x_data = range(0, iris.shape[0])
# create figure and axis
fig, ax = plt.subplots()
# plot each column
for column in columns:
    ax.plot(x_data, iris[column])
# set title and legend
ax.set_title('Iris Dataset')
ax.legend()

Histogram

In Matplotlib, we can create a Histogram the use of the hist approach. If we bypass specific information like the factors column from the wine-review dataset, it's going to mechanically calculate how frequently every elegance happens.

# create figure and axis
fig, ax = plt.subplots()
# plot histogram
ax.hist(wine_reviews['points'])
# set title and labels
ax.set_title('Wine Review Scores')
ax.set_xlabel('Points')
ax.set_ylabel('Frequency')

Bar Chart

A bar chart can be created the usage of the bar approach. The bar chart isn’t automatically calculating the frequency of a class, so we will use pandas value_counts technique to do that. The bar chart is useful for specific information that doesn’t have a lot of exclusive categories (less than 30) because else it could get pretty messy.

# create a figure and axis 
fig, ax = plt.subplots() 
# count the occurrence of each class 
data = wine_reviews['points'].value_counts() 
# get x and y data 
points = data.index 
frequency = data.values 
# create bar chart 
ax.bar(points, frequency) 
# set title and labels 
ax.set_title('Wine Review Scores') 
ax.set_xlabel('Points') 
ax.set_ylabel('Frequency')

Pandas Visualization

Pandas is an open-supply, excessive-performance, and smooth-to-use library imparting facts structures, including facts frames and facts analysis equipment just like the visualization equipment we will use in this newsletter.

Pandas Visualization makes it smooth to create plots out of a pandas dataframe and collection. It also has a higher-level API than Matplotlib, and consequently we need less code for the same effects.

Pandas can be established the use of either pip or conda.

pip install pandas
or
conda install pandas

Scatter Plot

To create a scatter plot in Pandas, we will name <dataset>.plot.scatter() and skip it two arguments, the name of the x-column and the name of the y-column. Optionally we also can give it a identify.

iris.plot.scatter(x='sepal_length', y='sepal_width', title='Iris Dataset')

As you may see in the image, it's miles mechanically setting the x and y label to the column names.

Line Chart

To create a line chart in Pandas we will name <dataframe>.plot.line(). While in Matplotlib, we needed to loop via every column we wanted to plan, in Pandas we don’t want to do this because it automatically plots all available numeric columns (at the least if we don’t specify a selected column/s).

iris.drop(['class'], axis=1).plot.line(title='Iris Dataset')

If we've got a couple of characteristic, Pandas mechanically creates a legend for us, as seen within the photo above.

Histogram

In Pandas, we are able to create a Histogram with the plot.hist approach. There aren’t any required arguments, however we can optionally bypass a few like the bin size.

wine_reviews['points'].plot.hist()

It’s also trustworthy to create multiple histograms.

iris.plot.hist(subplots=True, layout=(2,2), figsize=(10, 10), bins=20)

The subplots argument specifies that we want a separate plot for every function, and the format specifies the wide variety of plots in keeping with row and column.

Bar Chart

To plot a bar chart, we can use the plot.bar() method, however earlier than calling this, we need to get our records. We will first rely the occurrences the use of the value_count() technique after which sort the occurrences from smallest to biggest the use of the sort_index() approach.

wine_reviews['points'].value_counts().sort_index().plot.bar()

It’s also absolutely easy to make a horizontal bar chart the usage of the plot.barh() method.

wine_reviews['points'].value_counts().sort_index().plot.barh()

Python

We can also plot other records than the quantity of occurrences.

wine_reviews.groupby("country").price.mean().sort_values(ascending=False)[:5].plot.bar()

In the example above, we grouped the statistics via u . S ., took the suggest of the wine costs, ordered it, and plotted the 5 countries with the very best average wine price.

Seaborn

Seaborn is a Python statistics visualization library based totally on Matplotlib. It offers a high-stage interface for creating appealing graphs.

Seaborn has a lot to provide. For instance, you may create graphs in a single line that might take multiple tens of strains in Matplotlib. Its popular designs are extremely good, and it additionally has a nice interface for working with Pandas dataframes.

It may be imported by typing:

import seaborn as sns

Scatter plot

We can use the .scatterplot technique for creating a scatterplot, and simply as in Pandas, we want to pass it the column names of the x and y records, but now we also want to pass the facts as a further argument due to the fact we aren’t calling the feature on the statistics without delay as we did in  Pandas.

sns.scatterplot(x='sepal_length', y='sepal_width', data=iris)

We can also spotlight the factors by way of class the use of the hue argument, which is a lot easier than in Matplotlib.

sns.scatterplot(x='sepal_length', y='sepal_width', hue='class', data=iris)

Line chart

To create a line chart, the sns.lineplot approach may be used. The handiest required argument is the records, which in our case are the 4 numeric columns from the Iris dataset. We could also use the sns.kdeplot approach, which smoothes the rims of the curves and therefore is cleaner if you have a number of outliers in your dataset.

sns.lineplot(data=iris.drop(['class'], axis=1))

Histogram

To create a histogram in Seaborn, we use the sns.distplot technique. We want to pass it the column we need to plan, and it's going to calculate the occurrences itself. We can also pass it the range of boxes and if we want to plot a gaussian kernel density estimate in the graph.

sns.distplot(wine_reviews['points'], bins=10, kde=False)

sns.distplot(wine_reviews['points'], bins=10, kde=True)

Bar chart

In Seaborn, a bar chart can be created the usage of the sns.countplot approach and passing it the facts.

sns.countplot(wine_reviews['points'])

Other graphs

Now that you have a basic know-how of the Matplotlib, Pandas Visualization, and Seaborn syntax, I need to show you a few different graph kinds which are beneficial for extracting insides.

For maximum of them, Seaborn is the pass-to library due to its high-stage interface that lets in for the advent of stunning graphs in only a few traces of code.

Box plots

A Box Plot is a graphical method of displaying the 5-range summary. We can create box plots the use of seaborn's sns.boxplot approach and passing it the statistics as well as the x and y column names.

df = wine_reviews[(wine_reviews['points']>=95) & (wine_reviews['price']<1000)]
sns.boxplot('points', 'price', data=df)

Box Plots, much like bar charts, are remarkable for information with only some categories but can get messy speedy.

Heatmap

A Heatmap is a graphical representation of facts in which the individual values contained in a matrix are represented as hues. Heatmaps are perfect for exploring the correlation of functions in a dataset.

To get the correlation of the capabilities inside a dataset, we can name <dataset>.Corr(), which is a Pandas dataframe method. This will provide us the correlation matrix.

We can now use either Matplotlib or Seaborn to create the heatmap.

Matplotlib:

# get correlation matrix
corr = iris.corr()
fig, ax = plt.subplots()
# create heatmap
im = ax.imshow(corr.values)

# set labels
ax.set_xticks(np.arange(len(corr.columns)))
ax.set_yticks(np.arange(len(corr.columns)))
ax.set_xticklabels(corr.columns)
ax.set_yticklabels(corr.columns)

# Rotate the tick labels and set their alignment.
plt.setp(ax.get_xticklabels(), rotation=45, ha="right",
rotation_mode="anchor")

To add annotations to the heatmap, we need to add two for loops:

# get correlation matrix
corr = iris.corr()
fig, ax = plt.subplots()
# create heatmap
im = ax.imshow(corr.values)

# set labels
ax.set_xticks(np.arange(len(corr.columns)))
ax.set_yticks(np.arange(len(corr.columns)))
ax.set_xticklabels(corr.columns)
ax.set_yticklabels(corr.columns)

# Rotate the tick labels and set their alignment.
plt.setp(ax.get_xticklabels(), rotation=45, ha="right",
         rotation_mode="anchor")

# Loop over data dimensions and create text annotations.
for i in range(len(corr.columns)):
    for j in range(len(corr.columns)):
        text = ax.text(j, i, np.around(corr.iloc[i, j], decimals=2),
ha="center", va="center", color="black")

Seaborn makes it manner less difficult to create a heatmap and upload annotations:

sns.heatmap(iris.corr(), annot=True)

Faceting

Faceting is the act of breaking statistics variables up across more than one subplots and mixing the ones subplots into a single determine.

Faceting is useful if you want to discover your dataset quickly.

To use one type of faceting in Seaborn, we will use the FacetGrid. First of all, we need to outline the FacetGrid and bypass it our records as well as a row or column, a good way to be used to break up the records. Then we want to name the map feature on our FacetGrid item and outline the plot type we want to apply and the column we want to graph.

g = sns.FacetGrid(iris, col='class')
g = g.map(sns.kdeplot, 'sepal_length')

You can make plots bigger and more complex than the instance above. You can discover a few examples right here.

Pairplot

Lastly, I will display you Seaborns pairplot and Pandas scatter_matrix, which enable you to plan a grid of pairwise relationships in a dataset.

sns.pairplot(iris)

from pandas.plotting import scatter_matrix

fig, ax = plt.subplots(figsize=(12,12))
scatter_matrix(iris, alpha=1, ax=ax)

As you may see in the pictures above, these techniques are always plotting two functions with each other. The diagonal of the graph is packed with histograms, and the other plots are scatter plots.

Conclusion

Data visualization is the field of seeking to apprehend records by using placing it in a visible context in order that patterns, traits, and correlations that may not otherwise be detected may be uncovered.

Python gives multiple splendid graphing libraries packed with plenty of different functions. In this article, we looked at Matplotlib, Pandas visualization, and Seaborn.

Golden card:

Click Me For :

1.  1:1 Paid Session
2.  1:1 Sessions for different soft skill courses
3.  Project Development

Related Articles :

1. Learn Python
2. Python Inside The Cloud
3. Python In Excel

Your Feed_Back Is My Gift