4.3 Interactive Data Visuals with Plotly

4.3 Interactive Data Visuals with Plotly

Plotly is a Python visualization library used to create interactive and web-ready data visualizations. Unlike traditional static charts, Plotly charts allow users to interact directly with the visualization.

Users can typically hover over data points, zoom into regions, pan across charts, hide or display data series, and reset the view.

1. What Is Plotly?

Plotly is a graphing library designed for interactive, publication-quality visualizations.

Plotly visualizations are particularly useful for:

• Exploratory Data Analysis
• Interactive reports
• Web dashboards
• Business intelligence
• Scientific visualization
• Financial analysis
• Machine Learning analysis
• Data presentation

2. Plotly vs Matplotlib vs Seaborn

3. Installing Plotly

Install Plotly using pip:

pip install plotly

With Conda:

conda install -c conda-forge plotly

In a Jupyter Notebook:

%pip install plotly

4. Importing Plotly

Plotly provides a high-level interface called Plotly Express.

import plotly.express as px

For more detailed control, Plotly also provides Graph Objects.

import plotly.graph_objects as go

Many beginner and intermediate visualizations can be created efficiently using Plotly Express.

5. Your First Interactive Plotly Chart

import plotly.express as px

months = [
    "Jan",
    "Feb",
    "Mar",
    "Apr",
    "May"
]

sales = [
    120,
    150,
    135,
    180,
    210
]

fig = px.line(
    x=months,
    y=sales,
    title="Monthly Sales"
)

fig.show()

The resulting chart is interactive. Depending on the environment, users can hover over points, zoom, pan, and use the chart toolbar.

6. Plotly Express

Plotly Express provides concise functions for creating commonly used interactive visualizations.

The conventional alias is:

import plotly.express as px

Common Plotly Express functions include:

7. Plotly with pandas DataFrames

Plotly Express works naturally with pandas DataFrames.

import pandas as pd
import plotly.express as px

df = pd.DataFrame({
    "Month": [
        "Jan",
        "Feb",
        "Mar",
        "Apr",
        "May"
    ],

    "Sales": [
        120,
        150,
        135,
        180,
        210
    ]
})

fig = px.line(
    df,
    x="Month",
    y="Sales",
    title="Monthly Sales"
)

fig.show()

8. Interactive Line Charts

Line charts are useful for showing trends over an ordered variable, especially time.

fig = px.line(
    df,
    x="Month",
    y="Sales",
    markers=True,
    title="Monthly Sales Trend"
)

fig.show()

The markers=True option displays markers at the observations.

9. Multiple Interactive Lines

df = pd.DataFrame({
    "Month": [
        "Jan", "Feb", "Mar", "Apr"
    ],

    "Online": [
        100, 120, 150, 170
    ],

    "Store": [
        80, 95, 110, 125
    ]
})

For Plotly Express, a long-form DataFrame is often convenient when comparing multiple series.

long_df = df.melt(
    id_vars="Month",
    var_name="Channel",
    value_name="Sales"
)

fig = px.line(
    long_df,
    x="Month",
    y="Sales",
    color="Channel",
    markers=True,
    title="Sales by Channel"
)

fig.show()

10. Interactive Bar Charts

products = pd.DataFrame({
    "Product": [
        "Laptop",
        "Tablet",
        "Phone",
        "Monitor"
    ],

    "Sales": [
        120,
        85,
        160,
        70
    ]
})

fig = px.bar(
    products,
    x="Product",
    y="Sales",
    title="Product Sales"
)

fig.show()

Hovering over a bar can display its underlying value.

11. Grouped Bar Charts

df = pd.DataFrame({
    "Product": [
        "Laptop",
        "Tablet",
        "Phone",
        "Monitor"
    ],

    "Online": [
        70,
        45,
        100,
        30
    ],

    "Store": [
        50,
        40,
        60,
        40
    ]
})

long_df = df.melt(
    id_vars="Product",
    var_name="Channel",
    value_name="Sales"
)

fig = px.bar(
    long_df,
    x="Product",
    y="Sales",
    color="Channel",
    barmode="group",
    title="Sales by Product and Channel"
)

fig.show()

12. Stacked Bar Charts

Change barmode to "stack".

fig = px.bar(
    long_df,
    x="Product",
    y="Sales",
    color="Channel",
    barmode="stack",
    title="Stacked Sales by Product"
)

fig.show()

13. Interactive Scatter Plots

Scatter plots are useful for investigating relationships between numerical variables.

df = pd.DataFrame({
    "StudyHours": [
        1, 2, 3, 4,
        5, 6, 7, 8
    ],

    "Score": [
        42, 50, 58, 64,
        70, 76, 84, 91
    ]
})

fig = px.scatter(
    df,
    x="StudyHours",
    y="Score",
    title="Study Hours vs Score"
)

fig.show()

14. Scatter Plot with Categories

df["Class"] = [
    "A",
    "A",
    "B",
    "B",
    "A",
    "B",
    "A",
    "B"
]

fig = px.scatter(
    df,
    x="StudyHours",
    y="Score",
    color="Class",
    title="Study Hours vs Score by Class"
)

fig.show()

The color parameter separates observations according to a categorical variable.

15. Bubble Charts with size

A numerical variable can control marker size.

df = pd.DataFrame({
    "Hours": [
        2, 4, 6, 8, 10
    ],

    "Score": [
        50, 60, 72, 84, 94
    ],

    "Students": [
        20, 35, 50, 40, 25
    ]
})

fig = px.scatter(
    df,
    x="Hours",
    y="Score",
    size="Students",
    title="Study Hours, Scores and Student Count"
)

fig.show()

16. Custom Hover Information

Interactive charts become particularly powerful when users can inspect additional information by hovering over points.

fig = px.scatter(
    df,
    x="Hours",
    y="Score",
    size="Students",
    hover_data=["Students"],
    title="Student Performance"
)

fig.show()

The hover_data parameter specifies additional columns that should appear in the hover information.

17. Custom Hover Templates

For advanced control over hover content, Plotly Graph Objects provide hovertemplate.

import plotly.graph_objects as go

fig = go.Figure()

fig.add_trace(
    go.Scatter(
        x=[1, 2, 3],
        y=[50, 65, 80],
        mode="markers",
        hovertemplate=
            "Hours: %{x}
" +
            "Score: %{y}"
    )
)

fig.show()

This approach gives precise control over what appears when a user hovers over a data point.

18. Interactive Histograms

scores = pd.DataFrame({
    "Score": [
        45, 52, 56, 61,
        64, 67, 70, 72,
        75, 78, 81, 84,
        87, 90, 94, 98
    ]
})

fig = px.histogram(
    scores,
    x="Score",
    title="Examination Score Distribution"
)

fig.show()

Users can interact with the chart to inspect the distribution.

19. Histogram by Category

df = pd.DataFrame({
    "Score": [
        45, 52, 58, 62,
        68, 72, 76, 80,
        84, 88, 91, 95
    ],

    "Class": [
        "A", "A", "B", "B",
        "A", "B", "A", "B",
        "A", "B", "A", "B"
    ]
})

fig = px.histogram(
    df,
    x="Score",
    color="Class",
    title="Score Distribution by Class"
)

fig.show()

20. Interactive Box Plots

fig = px.box(
    df,
    y="Score",
    title="Score Distribution"
)

fig.show()

Box plots are useful for comparing median, spread, quartiles, and potential outliers.

21. Box Plot by Category

fig = px.box(
    df,
    x="Class",
    y="Score",
    color="Class",
    title="Score Distribution by Class"
)

fig.show()

22. Interactive Violin Plots

fig = px.violin(
    df,
    x="Class",
    y="Score",
    color="Class",
    box=True,
    points="all",
    title="Score Distribution by Class"
)

fig.show()

Here:

• box=True adds a box plot representation.
• points="all" displays individual observations.

23. Interactive Pie Charts

data = pd.DataFrame({
    "Category": [
        "Science",
        "Commerce",
        "Humanities",
        "Technology"
    ],

    "Students": [
        180,
        150,
        120,
        210
    ]
})

fig = px.pie(
    data,
    names="Category",
    values="Students",
    title="Students by Department"
)

fig.show()

24. Donut Charts

A donut chart can be created by specifying a hole in a Plotly pie chart.

fig = px.pie(
    data,
    names="Category",
    values="Students",
    hole=0.4,
    title="Students by Department"
)

fig.show()

25. Interactive Area Charts

df = pd.DataFrame({
    "Month": [
        "Jan",
        "Feb",
        "Mar",
        "Apr"
    ],

    "Sales": [
        120,
        150,
        135,
        180
    ]
})

fig = px.area(
    df,
    x="Month",
    y="Sales",
    title="Monthly Sales"
)

fig.show()

Area charts emphasize the magnitude of values over an ordered dimension.

26. Faceting Interactive Charts

Plotly Express can create multiple panels based on categorical variables.

fig = px.scatter(
    df,
    x="Hours",
    y="Score",
    facet_col="Class",
    title="Study Hours vs Score by Class"
)

fig.show()

Faceting is useful when comparing groups separately while keeping the same analytical structure.

27. Animated Visualizations

Plotly can animate charts across a variable such as time.

fig = px.scatter(
    df,
    x="Hours",
    y="Score",
    animation_frame="Year",
    animation_group="Student",
    color="Class",
    title="Student Performance Over Time"
)

fig.show()

28. Interactive 3D Scatter Plots

Plotly supports interactive three-dimensional visualizations.

df = pd.DataFrame({
    "Height": [
        150, 160, 165, 170,
        175, 180, 185
    ],

    "Weight": [
        45, 52, 58, 64,
        70, 76, 82
    ],

    "Age": [
        12, 13, 14, 15,
        16, 17, 18
    ]
})

fig = px.scatter_3d(
    df,
    x="Height",
    y="Weight",
    z="Age",
    title="Height, Weight and Age"
)

fig.show()

Users can rotate and inspect the three-dimensional visualization interactively.

29. Adding a Fourth Dimension to a 3D Chart

A fourth variable can be represented through marker color.

fig = px.scatter_3d(
    df,
    x="Height",
    y="Weight",
    z="Age",
    color="Weight",
    title="3D Student Data"
)

fig.show()

30. Interactive Subplots

Multiple interactive charts can be combined into one figure using Plotly's subplot functionality.

from plotly.subplots import make_subplots
import plotly.graph_objects as go

fig = make_subplots(
    rows=1,
    cols=2,
    subplot_titles=(
        "Sales Trend",
        "Product Sales"
    )
)

fig.add_trace(
    go.Scatter(
        x=["Jan", "Feb", "Mar"],
        y=[120, 150, 180],
        mode="lines+markers",
        name="Sales"
    ),
    row=1,
    col=1
)

fig.add_trace(
    go.Bar(
        x=["Laptop", "Tablet", "Phone"],
        y=[120, 85, 160],
        name="Products"
    ),
    row=1,
    col=2
)

fig.show()

31. Plotly Graph Objects

Graph Objects provide lower-level control over Plotly figures.

import plotly.graph_objects as go

fig = go.Figure()

fig.add_trace(
    go.Scatter(
        x=["Jan", "Feb", "Mar"],
        y=[120, 150, 180],
        mode="lines+markers",
        name="Sales"
    )
)

fig.update_layout(
    title="Monthly Sales",
    xaxis_title="Month",
    yaxis_title="Sales"
)

fig.show()

32. Customizing the Figure Layout

Use update_layout() to modify many aspects of a Plotly figure.

fig.update_layout(
    title="Monthly Sales",
    xaxis_title="Month",
    yaxis_title="Revenue"
)

fig.show()

Other layout properties can control dimensions, margins, legends, axes, annotations, and interaction behavior.

33. Updating Data Traces

Plotly allows trace-level properties to be modified after a figure has been created.

fig.update_traces(
    marker_size=10
)

fig.show()

This is useful when you want to apply a consistent change to plotted traces.

34. Controlling Axis Ranges

fig.update_layout(
    xaxis_range=[0, 10],
    yaxis_range=[0, 100]
)

fig.show()

Axis ranges can also be configured directly through Plotly's axis-related properties.

35. Logarithmic Axes

Logarithmic scales can be useful when values span several orders of magnitude.

fig.update_layout(
    yaxis_type="log"
)

fig.show()

36. Using Plotly for Web Dashboards

Interactive Plotly figures can be used as building blocks for web-based analytical dashboards.

A typical dashboard may contain:

• Key Performance Indicators (KPIs)
• Revenue trends
• Category comparisons
• Geographical analysis
• Interactive filters
• Distribution charts
• Correlation analysis

37. Exporting a Plotly Chart to HTML

One of Plotly's major advantages is the ability to save an interactive visualization as an HTML file.

fig.write_html(
    "sales_chart.html"
)

The resulting HTML file can be opened in a browser and can retain the interactive chart experience.

38. Creating a Complete HTML Visualization

fig.write_html(
    "monthly_sales.html",
    full_html=True
)

This creates a complete HTML document containing the visualization.

39. Embedding a Plotly Chart into a Web Page

Plotly figures can also be converted into HTML fragments that can be embedded into an existing webpage.

html_code = fig.to_html(
    full_html=False
)

print(html_code)

This approach is useful when a developer already has an HTML page and wants to place an interactive Plotly figure inside it.

40. Basic Web Dashboard Architecture

Database / CSV / API
        ↓
Python + pandas
        ↓
Data Cleaning
        ↓
Plotly
        ↓
Interactive Figures
        ↓
Web Application / Dashboard
        ↓
User Interaction

Plotly can therefore act as the visualization layer in a larger data application.

41. Filtering Data Before Visualization

Interactive visualization begins with meaningful data selection. pandas can be used to filter the data before passing it to Plotly.

filtered_df = df[
    df["Score"] >= 70
]

fig = px.scatter(
    filtered_df,
    x="Hours",
    y="Score",
    color="Class",
    title="Students Scoring 70 or Above"
)

fig.show()

In a full dashboard, filters can be connected to user interface controls using a suitable dashboard framework.

42. Plotly and Dash

Dash is a framework for building analytical web applications using Python and Plotly.

A typical Dash application can combine:

• Interactive Plotly graphs
• Dropdowns
• Buttons
• Sliders
• Input controls
• Tables
• Callbacks

The conceptual architecture is:

User Input
    ↓
Dash Callback
    ↓
Data Processing
    ↓
Plotly Figure
    ↓
Updated Dashboard

43. Adding Annotations

Annotations can highlight important points or explain observations within a chart.

fig.add_annotation(
    x="Mar",
    y=180,
    text="Peak Sales",
    showarrow=True
)

fig.show()

Annotations can be especially useful in business reports and analytical dashboards.

44. Interactive Range Sliders

A range slider can allow users to select a portion of a time series.

fig = px.line(
    df,
    x="Date",
    y="Sales",
    title="Sales Trend"
)

fig.update_xaxes(
    rangeslider_visible=True
)

fig.show()

45. Range Selector Buttons

fig.update_xaxes(
    rangeslider_visible=True,
    rangeselector=dict(
        buttons=[
            dict(
                count=1,
                label="1m",
                step="month",
                stepmode="backward"
            ),
            dict(
                count=6,
                label="6m",
                step="month",
                stepmode="backward"
            ),
            dict(
                step="all",
                label="All"
            )
        ]
    )
)

fig.show()

Range selectors are especially useful for time-series dashboards.

46. Multiple Y-Axes

Some dashboards need to compare variables with very different scales.

fig = go.Figure()

fig.add_trace(
    go.Scatter(
        x=["Jan", "Feb", "Mar"],
        y=[100, 120, 150],
        name="Revenue"
    )
)

fig.add_trace(
    go.Scatter(
        x=["Jan", "Feb", "Mar"],
        y=[20, 25, 30],
        name="Orders",
        yaxis="y2"
    )
)

fig.update_layout(
    yaxis=dict(
        title="Revenue"
    ),

    yaxis2=dict(
        title="Orders",
        overlaying="y",
        side="right"
    )
)

fig.show()

47. Principles of Interactive Dashboard Design

1. Start with the analytical question.
2. Place important KPIs where users see them quickly.
3. Use consistent terminology and units.
4. Keep interactive controls understandable.
5. Use hover information to provide detail without overcrowding the chart.
6. Provide meaningful titles.
7. Avoid unnecessary animation.
8. Make filtering behavior obvious.
9. Keep related charts visually consistent.
10. Ensure the dashboard remains understandable without requiring users to inspect the underlying code.

48. Common Plotly Mistakes

49. Plotly Interview Questions

import plotly.express as px

fig.write_html("chart.html")

50. Examination Questions — MCQs

51. Practical Examination Questions

import pandas as pd
import plotly.express as px

df = pd.DataFrame({
    "Month": [
        "Jan",
        "Feb",
        "Mar",
        "Apr"
    ],

    "Visitors": [
        1200,
        1500,
        1800,
        2100
    ]
})

fig = px.line(
    df,
    x="Month",
    y="Visitors",
    markers=True,
    title="Monthly Website Visitors"
)

fig.show()

df = pd.DataFrame({
    "Product": [
        "Laptop",
        "Tablet",
        "Phone",
        "Monitor"
    ],

    "Sales": [
        120,
        85,
        160,
        70
    ]
})

fig = px.bar(
    df,
    x="Product",
    y="Sales",
    title="Product Sales"
)

fig.show()

fig = px.scatter(
    df,
    x="Hours",
    y="Score",
    color="Class",
    title="Study Hours vs Score"
)

fig.show()

fig.write_html(
    "interactive_chart.html"
)

correlation = df.corr(
    numeric_only=True
)

fig = px.imshow(
    correlation,
    text_auto=True,
    title="Correlation Matrix"
)

fig.show()

52. Scenario-Based Questions

53. Quick-Fire Interview Revision

55. Key Takeaways

• Plotly is designed for interactive and web-ready data visualization.
• Plotly Express provides concise functions for common charts.
• Graph Objects provide more detailed control over figures and traces.
• Interactive charts can provide hover information, zooming, panning, filtering-style interactions, and other controls.
• Plotly works naturally with pandas DataFrames.
• color, size, and hover_data allow additional variables to be represented in a chart.
• Plotly supports 2D, 3D, faceted, animated, and multi-chart visualizations.
• fig.write_html() can export interactive visualizations as HTML.
• Plotly figures can serve as the visualization layer of analytical web dashboards.
• Dash can be used when a complete interactive analytical web application is required.
• Interactivity should improve analysis rather than become a distraction.