Plotly for Data Visualization in Python

Plotly is an open-source Python library for creating interactive visualizations like line charts, scatter plots, bar charts and more. In this article, we will explore plotting in Plotly and covers how to create basic charts and enhance them with interactive features.

Introduction to Plotly in Python

Plotly is a Python library that helps you create interactive and visually appealing charts and graphs. It allows you to display data in a way that’s easy to explore and understand, such as by zooming in, hovering over data points for more details, and clicking to get deeper insights Plotly uses JavaScript to handle interactivity, but you don’t need to worry about that when using it in Python. You simply write Python code to create the charts, and Plotly takes care of making them interactive.

Plotly does not come built-in with Python. To install it type the below command in the terminal.

pip install plotly

Understanding Plotly Modules – Introduction

In Plotly, there are two main modules: 

• plotly.plotly acts as the interface between the local machine and Plotly. It contains functions that require a response from Plotly’s server.
• plotly.graph_objects module contains the objects (Figure, layout, data, and the definition of the plots like scatter plot, line chart) that are responsible for creating the plots. The Figure can be represented either as dict or instances of plotly.graph_objects.Figure and these are serialized as JSON before it gets passed to plotly.js. Figures are represented as trees where the root node has three top layer attributes – data, layout, and frames and the named nodes called ‘attributes’.

Example:

import plotly.express as px

fig = px.line(x=[1, 2], y=[3, 4])

print(fig)

Output:

plotly.tools module contains various tools in the forms of the functions that can enhance the Plotly experience. After going through the basics of plotly let’s see how to create some basic charts using plotly.

Getting Started with Basic Charts in Plotly

Here we will explore how to generate basic charts using Plotly and apply various customizations to enhance their appearance and functionality. We will learn how to visualize different graph like line charts, scatter plots, bar charts, histograms and pie charts. We will cover the following customizations:

• Adjusting chart layout
• Adding annotations
• Customizing markers and lines

1. Line chart

Plotly line chart is one of the simple plots where a line is drawn to show relation between the X-axis and Y-axis. It can be created using the px.line() method with each data position is represented as a vertex of a polyline mark in 2D space.

Syntax:

plotly.express.line(data_frame=None, x=None, y=None, line_group=None, color=None, line_dash=None, hover_name=None, hover_data=None, title=None, template=None, width=None, height=None)

Example:

import plotly.express as px

df = px.data.iris()

fig = px.line(df, y="sepal_width",)

fig.show()

Output:

In the above example, we can see that – 

• The labels to the x-axis and y-axis have given automatically by plotly.
• The data of the x-axis and y-axis is shown.
• We can also select a part of the data according to our needs and can also zoom out.
• Plotly also provides a set of tools (seen on the top right corner) to interact with every chart.
• Plotly also allows us to save the graph locally in a static format.

Now let’s try to customize our graph a little. 

Example 1: In this example we will use the line dash parameter which is used to group the lines according to the dataframe column passed.

import plotly.express as px

df = px.data.iris()

fig = px.line(df, y="sepal_width", line_group='species')

fig.show()

Output:

Example 2: In this example, we will group and color the data according to the species. We will also change the line format. For this we will use two attributes such line_dash and color.

import plotly.express as px

df = px.data.iris()

fig = px.line(df, y="sepal_width", line_dash='species',
              color='species')

fig.show()

Output:

2. Bar Chart

A bar chart is a pictorial representation of data that presents categorical data with rectangular bars with heights or lengths proportional to the values that they represent. These data sets contain the numerical values of variables that represent the length or height. It can be created using the px.bar() method.

Syntax:

plotly.express.bar(data_frame=None, x=None, y=None, color=None, facet_row=None, facet_col=None, facet_col_wrap=0, hover_name=None, hover_data=None, custom_data=None, text=None, error_x=None, error_x_minus=None, error_y=None, error_y_minus=None, title=None, template=None, width=None, height=None)

Example:

import plotly.express as px

df = px.data.tips()

fig = px.bar(df, x='day', y="total_bill")

fig.show()

Output:

Let’s try to customize this plot. Customizations that we will use –

• color: Used to color the bars.
• facet_row: Divides the graph into rows according to the data passed
• facet_col: Divides the graph into columns according to the data passed

Example:

import plotly.express as px

df = px.data.tips()

fig = px.bar(df, x='day', y="total_bill", color='sex',
             facet_row='time', facet_col='sex')

fig.show()

Output:

3. Scatter Plot

A scatter plot is a set of dotted points to represent individual pieces of data in the horizontal and vertical axis. A graph in which the values of two variables are plotted along X-axis and Y-axis the pattern of the resulting points reveals a correlation between them and it can be created using the px.scatter() method.

Syntax:

plotly.express.scatter(data_frame=None, x=None, y=None, color=None, symbol=None, size=None, hover_name=None, hover_data=None, facet_row=None, facet_col=None, facet_col_wrap=0, opacity=None, title=None, template=None, width=None, height=None)

Example:

import plotly.express as px

df = px.data.tips()

fig = px.scatter(df, x='total_bill', y="tip")

fig.show()

Output:

Let’s see various customizations available for this chart that we will use – 

• color: Color the points.
• symbol: Gives a symbol to each point according to the data passed.
• size: The size for each point.

Example:

import plotly.express as px

df = px.data.tips()

fig = px.scatter(df, x='total_bill', y="tip", color='time',
                 symbol='sex', size='size', facet_row='day',
                 facet_col='time')

fig.show()

Output:

4. Histogram

A histogram is basically used to represent data in the form of some groups. It is a type of bar plot where the X-axis represents the bin ranges while the Y-axis gives information about frequency. It can be created using the px.histogram() method.

Syntax: 

plotly.express.histogram(data_frame=None, x=None, y=None, color=None, facet_row=None, facet_col=None, barnorm=None, histnorm=None, nbins=None, title=None, template=None, width=None, height=None)

Example:

import plotly.express as px

df = px.data.tips()

fig = px.histogram(df, x="total_bill")

fig.show()

Output:

Let’s customize the above graph. Customizations that we will be using are – 

• color: To color the bars
• nbins: To set the number of bins
• histnorm: Mode through which the bins are represented. Different values that can be passed using this argument.
• barmode: Can be either ‘group’, ‘overlay’ or ‘relative’.
  • group: Bars are stacked above zero for positive values and below zero for negative values
  • overlay: Bars are drawn on the top of each other
  • group: Bars are placed beside each other.

Example:

import plotly.express as px

df = px.data.tips()

fig = px.histogram(df, x="total_bill", color='sex',
                   nbins=50, histnorm='percent',
                   barmode='overlay')

fig.show()

Output:

5. Pie Chart

A pie chart is a circular statistical graphic, which is divided into slices to illustrate numerical proportions. It depicts a special chart that uses “pie slices”, where each sector shows the relative sizes of data. A circular chart cuts in a form of radii into segments to magnitude of different features. It can be created using the px.pie() method.

Syntax:

plotly.express.pie(data_frame=None, names=None, values=None, color=None, color_discrete_sequence=None, color_discrete_map={}, hover_name=None, hover_data=None, custom_data=None, labels={}, title=None, template=None, width=None, height=None, opacity=None, hole=None)

Example:

import plotly.express as px

df = px.data.tips()

fig = px.pie(df, values="total_bill", names="day")
fig.show()

Output:

Let’s customize the above graph. Customizations that we will be using are – 

• color_discrete_sequence: Strings defining valid CSS colors
• opacity: It determines how transparent or solid the markers (such as points on a scatter plot) appear. The value should be between 0 and 1
• hole: Creates a hole in between to make it a donut chart. The value should be between 0 and 1

Example:

import plotly.express as px

df = px.data.tips()

fig = px.pie(df, values="total_bill", names="day",
             color_discrete_sequence=px.colors.sequential.RdBu,
             opacity=0.7, hole=0.5)
fig.show()

Output:

6. Box Plot

A Box Plot is also known as Whisker plot is created to display the summary of the set of data values having properties like minimum, first quartile, median, third quartile and maximum. In the box plot, a box is created from the first quartile to the third quartile, a vertical line is also there which goes through the box at the median. Here x-axis denotes the data to be plotted while the y-axis shows the frequency distribution. It can be created using the px.box() method

Syntax:

plotly.express.box(data_frame=None, x=None, y=None, color=None, facet_row=None, facet_col=None, title=None, template=None, width=None, height=None)

Example:

import plotly.express as px

df = px.data.tips()

fig = px.box(df, x="day", y="tip")

fig.show()

Output:

Let’s see various customizations that can be used on boxplots – 

• color: used to assign color to marks
• facet_row: assign marks to facetted subplots in the vertical direction
• facet_col: assign marks to facetted subplots in the horizontal direction
• boxmode: One of ‘group’ or ‘overlay’ In ‘overlay’ mode, boxes are on drawn top of one another. In ‘group’ mode, boxes are placed beside each other.
• notched: If True, boxes are drawn with notches

Example:

import plotly.express as px

df = px.data.tips()

fig = px.box(df, x="day", y="tip", color='sex',
             facet_row='time', boxmode='group',
             notched=True)

fig.show()

Output:

7. Violin Plot

Violin Plot is a method to visualize the distribution of numerical data of different variables. It is similar to Box Plot but with a rotated plot on each side, giving more information about the density estimate on the y-axis. The density is mirrored and flipped over and the resulting shape is filled in creating an image resembling a violin. The advantage of a violin plot is that it can show distribution that aren’t shown in a boxplot. On the other hand the boxplot more clearly shows the outliers in the data. It can be created using the px.violin() method.

Syntax:

violin(data_frame=None, x=None, y=None, color=None, facet_row=None, facet_col=None, facet_col_wrap=0, facet_row_spacing=None, facet_col_spacing=None, hover_name=None, hover_data=None, title=None, template=None, width=None, height=None, **kwargs)

Example:

import plotly.express as px

df = px.data.tips()

fig = px.violin(df, x="day", y="tip")

fig.show()

Output:

For customizing the violin plot we will use the same customizations available for the box plot except the boxmode and notched which are not available for the violin plot Setting this parameter to True will show a box plot inside the violin plot.

Example:

import plotly.express as px

df = px.data.tips()

fig = px.violin(df, x="day", y="tip", color='sex',
                facet_row='time', box=True)

fig.show()

Output:

8. 3D Scatter Plot

3D Scatter Plot shows data points in three dimensions, adding extra information by adjusting color, size, and style of the points. These adjustments help make the plot clearer and easier to understand. You can create a 3D scatter plot using the scatter_3d function from the plotly.express class.

Syntax:

plotly.express.scatter_3d(data_frame=None, x=None, y=None, z=None, color=None, symbol=None, size=None, range_x=None, range_y=None, range_z=None, title=None, template=None, width=None, height=None, **kwargs)

Example:

import plotly.express as px

df = px.data.tips()

fig = px.scatter_3d(df, x="total_bill", y="sex", z="tip")

fig.show()

Output:

Customizing the 3D scatter plot. We will use the following customization – 

• color: Set the color of the markers
• size: Set the size of the marker
• symbol: Set the symbol of the plot

Example:

import plotly.express as px

df = px.data.tips()

fig = px.scatter_3d(df, x="total_bill", y="sex", z="tip", color='day', 
                    size='total_bill', symbol='time')

fig.show()

Output:

Implementing Interactive Features to the Plots

Every graph created by the plotly provides various interactions where we can select a part of the plot to get information over that part of the plot and also can do many tasks like saving the plot locally or zooming in and out, etc. Besides all these plotly allows us to add more tools like dropdowns, buttons, sliders, etc. These can be created using the update menu attribute of the plot layout. Let’s see how to do all such things in detail.

1. Dropdown Menu

A drop-down menu is a part of the menu button which is displayed on a screen all the time. Every menu button is associated with a Menu widget that can display the choices for that menu button when clicked on it. In plotly there are 4 possible methods to modify the charts by using update menu method.

• restyle: modify data or data attributes
• relayout: modify layout attributes
• update: modify data and layout attributes
• animate: start or pause an animation

Example:

import plotly.graph_objects as px
import numpy as np
import pandas as pd

df = pd.read_csv('tips.csv')

plot = px.Figure(data=[px.Scatter(
    x=df['day'],
    y=df['tip'],
    mode='markers',)
])

plot.update_layout(
    updatemenus=[
        dict(buttons=list([
            dict(
                args=["type", "scatter"],
                label="Scatter Plot",
                method="restyle"
            ),
            dict(
                args=["type", "bar"],
                label="Bar Chart",
                method="restyle"
            )
        ]),
            direction="down",
        ),
    ]
)

plot.show()

Output:

2. Adding Buttons

In plotly, adding custom Buttons are used to quickly make actions directly from a record. Custom Buttons can be added to page layouts in CRM, Marketing, and Custom Apps. There are also 4 possible methods that can be applied in custom buttons:

• restyle: modify data or data attributes
• relayout: modify layout attributes
• update: modify data and layout attributes
• animate: start or pause an animation

Example:

import plotly.graph_objects as px
import pandas as pd

data = pd.read_csv("tips.csv")


plot = px.Figure(data=[px.Scatter(
    x=data['day'],
    y=data['tip'],
    mode='markers',)
])

plot.update_layout(
    updatemenus=[
        dict(
            type="buttons",
            direction="left",
            buttons=list([
                dict(
                    args=["type", "scatter"],
                    label="Scatter Plot",
                    method="restyle"
                ),
                dict(
                    args=["type", "bar"],
                    label="Bar Chart",
                    method="restyle"
                )
            ]),
        ),
    ]
)

plot.show()

Output:

3. Creating Sliders and Selectors to the Plot

In plotly the range slider is a custom range-type input control. It allows selecting a value or a range of values between a specified minimum and maximum range. And the range selector is a tool for selecting ranges to display within the chart. It provides buttons to select pre-configured ranges in the chart. It also provides input boxes where the minimum and maximum dates can be manually input.

Example:

import plotly.graph_objects as px
import plotly.express as go
import numpy as np

df = go.data.tips()

x = df['total_bill']
y = df['tip']

plot = px.Figure(data=[px.Scatter(
    x=x,
    y=y,
    mode='markers',)
])

plot.update_layout(
    xaxis=dict(
        rangeselector=dict(
            buttons=list([
                dict(count=1,
                    step="day",
                    stepmode="backward"),
            ])
        ),
        rangeslider=dict(
            visible=True
        ),
    )
)

plot.show()

Output:

Building Interactive Dashboards with Plotly Dash

Plotly Dash is a powerful framework for building interactive web applications with Python. It allows you to create dynamic and visually appealing dashboards that can handle complex interactions and data visualizations. In this section, we will explore the essentials of building interactive dashboards using Plotly Dash.

For more advanced interactive applications, we can use Plotly Dash to create dashboards. Here’s a basic example of a Dash app:

1. Install the necessary packages:

!pip install dash jupyter-dash plotly pandas

2. Use the JupyterDash class to create and run the Dash:

import dash
from dash import dcc, html
import plotly.express as px
import pandas as pd
from jupyter_dash import JupyterDash

df = pd.DataFrame({
    'x': [1, 2, 3, 4, 5],
    'y': [10, 15, 13, 17, 14]
})

app = JupyterDash(__name__)

app.layout = html.Div([
    dcc.Graph(
        id='example-graph',
        figure=px.scatter(df, x='x', y='y', title='Scatter Plot in Dash')
    )
])

app.run_server(mode='inline')

Output:

Creating Dashboards

Plotly provides a rich set of tools for creating interactive visualizations in Python. From basic charts to complex interactive dashboards. By customizing our charts and using interactive features we can enhance your data exploration and communication.

N

nikhilaggarwal3

Follow

Improve

Article Tags :

• AI-ML-DS
• Data Visualization
• AI-ML-DS With Python
• Python Data Visualization
• Python-Plotly

+1 More