Creating Stunning Scatter Plots with Plotly Express

As a full-stack developer and Linux expert, I often need to visualize data to uncover insights. One of my favorite data visualization libraries is Plotly Express – the high-level API for Plotly.py. Plotly Express allows you to quickly create interactive browser-based charts perfect for analysis.

In this comprehensive 2600+ word guide, I‘ll walk you through how to create beautiful, informative scatter plots with Plotly Express. We‘ll cover the basics and then dive into more advanced topics like custom styling, statistical charts, interactivity, and access to the full Plotly API. By the end, you‘ll have the skills to build scatter plots that clearly communicate relationships in your data.

Scatter Plot Basics

A scatter plot displays the relationship between two numerical variables by marking data points on a graph. Each point‘s position depends on its values for the x and y variables. Scatter plots allow you to visually uncover correlations, clusters, and other patterns in data.

To create a scatter plot in Plotly Express, use the px.scatter() function:

import plotly.express as px

fig = px.scatter(x=[0, 1, 2, 3, 4], y=[1, 4, 9, 16, 25])
fig.show()

This plots the points (0, 1), (1, 4), (2, 9), (3, 16), and (4, 25).

By passing column names of a Pandas DataFrame instead of raw arrays, we can easily create scatter plots from data frames. The x and y values will come from the specified columns:

import pandas as pd
import plotly.express as px

df = pd.DataFrame({
  "a": [1, 2, 3, 4, 5],  
  "b": [2, 4, 8, 16, 32]   
})

fig = px.scatter(df, x="a", y="b") 
fig.show()

With just a few lines of code, we now have an informative scatter plot created from the DataFrame.

According to Plotly‘s documentation, px.scatter() also accepts the following parameters:

• animation_frame: Column to use for animation
• animation_group: Column to use for tracing animations
• color: Color of markers
• hover_name: Column to add to hover labels
• log_x: Plots on x-axis log scale
• size: Size of markers
• trendline: Add a trendline

And many more. These allow extensive customization as we will see soon.

Customizing Appearance

One major advantage of Plotly Express is how easily charts can be styled. To change the color of markers, pass a specific color name or hex code to the color parameter:

import plotly.express as px

fig = px.scatter(
    x=[0, 1, 2, 3, 4],
    y=[1, 2, 4, 8, 16], 
    color="rebeccapurple" # nice shade of purple
)
fig.show()

fig = px.scatter(
    x=[0, 1, 2, 3], 
    y=[5, 7, 3],
    color="#1E90FF" # vibrant blue
)
fig.show()

For categorical color mapping, pass a column of categories:

import pandas as pd
import plotly.express as px

df = pd.DataFrame({
  "x": [1, 2, 3, 4],
  "y": [2, 5, 10, 17],
  "category": ["A", "B", "A", "B"]  
})

fig = px.scatter(
    df, x="x", y="y", 
    color="category", # color by category column
)
fig.show()

This will color dots based on the "category" column values A and B.

For sequential, continuous color scales, pass a built-in color scale name:

from scipy.stats import norm
import plotly.express as px

r = np.random.randn(1000) 
df = pd.DataFrame({"x": range(1000), "y": norm.pdf(r) * 10 + 50}) 

fig = px.scatter(
    df, x="x", y="y", 
    color="y", # map color to y values
    color_continuous_scale=‘YlGnBu‘ # sequential color scale name
)
fig.show()

Plotly includes color scale names like Viridis, Cividis, Blues, and more documented here.

Beyond color, marker symbols can be changed through the symbol parameter, while size can be set directly or mapped to a column:

fig = px.scatter(
    tips, x="total_bill", y="tip", 
    size="size", # map size to column
    symbol="sex", # set symbols from column
)
fig.show()

Refer to Plotly‘s scatter plot documentation for a full styling options list. Tight control over appearance helps highlight patterns and trends.

Animated Scatter Plots

Another way to highlight changes in data is through animations. First, your data must include a variable to animate over, like "time", "year" or "month". You can then create animated scatter plots as follows:

df = pd.DataFrame({
    "x": [1, 2, 3, 4], 
    "y": [1, 4, 9, 16],
    "year": [2010, 2011, 2012, 2013]  
})

fig = px.scatter(
    df, x="x", y="y", 
    animation_frame="year", # animate over year
    animation_group="id" # optional grouping
)

fig.show()

This animates the scatter plot over "year", treating each point as a separate trace in the animation. Further configure animations by setting animation_frame, animation_group, and animation_speed. Refer to animations documentation for more details.

Animations are extremely effective at conveying changes over time in data. This lets you emphasize trends and dynamics that are core to analysis.

Statistical Charts

One excellent feature of Plotly Express is built-in statistical charts. These perform aggregations before plotting data and are perfect for starting analysis.

A box plot displays distributions with summary statistics:

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

df = pd.DataFrame(dict(
    category= ["A", "B", "C"]*50,
    value= np.random.rand(150)
))

fig = px.box(df, x="category", y="value")
fig.show() 

While violin plots show the full distribution shape, not just quartiles:

import plotly.express as px

fig = px.violin(df, x="category", y="value")
fig.show()

Scatter plot matrices visualize pairwise relationships between multiple numeric columns:

from sklearn.datasets import make_blobs 

# generate dummy dataset
data = make_blobs(n_samples=500, n_features=5, centers=5) 

df = pd.DataFrame(data[0], columns=range(5))

fig = px.scatter_matrix(df) 
fig.show()

Density heatmaps display concentrations with color scaling:

x = np.random.multivariate_normal([0, 0], [[5, 2], [2, 2]], size=2000)
df = pd.DataFrame(x, columns=[‘x‘, ‘y‘])

fig = px.density_heatmap(df, x=‘x‘, y=‘y‘)
fig.show()

Many more statistical charts like histogram, parallel categories, treemaps and ternary plots are included. These provide automated aggregation for understanding data distributions and relationships during exploration.

Interactivity

Plotly figures shine when adding interactivity like slider filters. This engages audiences and enables personalized Chart analysis:

import numpy as np
import plotly.express as px

df = pd.DataFrame(dict(
    weight=[170, 100, 40, 12],
    group=["A"]*2 + ["B"]*2
))

fig = px.scatter(df, x="weight", color="group")

fig.update_layout(
    xaxis=dict(
        rangeselector=dict(
            buttons=list([
                dict(count=1,
                     label="1m",
                     step="month",
                     stepmode="backward"),        
            ])
        ),
        rangeslider=dict(
            visible=True
        ),
    )
)

fig.show()

Here range and slider selectors filter the x-axis. More selectors, buttons, dropdowns, tooltips and other interactive elements are supported as discussed in Plotly‘s interactivity tutorial.

For exploration, interactivity enables drilling down into certain data ranges and points. This can uncover insights hidden when viewing the full dataset. Support for linked brushing across multiple charts also exists.

Accessing the Full Plotly API

While Plotly Express is convenient for building basic charts, Plotly Graph Objects provide complete control for advanced customization. Access this lower-level API after any high-level figure creation:

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

# create figure with Express  
fig = px.scatter(
    x=[0, 1, 2, 3, 4],
    y=[2, 3, 5, 7, 2]
)

# customize through Graph Objects  
fig.data[0].marker.color = "purple" # change marker colors
fig.layout.width = 300 # adjust layout
fig.layout.xaxis.title.text = "New X-Axis Label" # modify axes

# add new trace
fig.add_trace(go.Scatter(x=[1, 2, 3], y=[3, 1, 6], mode="lines"))   

fig.show()  

We can even build up figures completely through graph objects for absolute customization:

import plotly.graph_objects as go

fig = go.Figure() 

# Add Traces
fig.add_trace(
    go.Scatter(
        x=[0, 1, 3],
        y=[1, 3, 2],
        mode="markers" 
    )
)

fig.add_trace(
    go.Scatter(
        x=[2, 3, 4],
        y=[4, 2, 5], 
        mode="lines"
   )
)

# Set title and axes
fig.update_layout(
    title="My Plot",
    xaxis_title="X Axis Label",
    yaxis_title="Y Axis Label"  
)

# Display
fig.show()

Custom data transformations can also be applied before plotting. Refer to Plotly Graph Objects documentation for more details.

Geographic Mapping

Another powerful Plotly feature is geographic data visualization. Plot latitude/longitude data points on maps with px.scatter_geo():

import pandas as pd 
import plotly.express as px

df = pd.DataFrame(dict(
    lat=[45.5, 45.6, 45.8],  
    lon=[-73.7, -73.9, -73.6],
    size=[10, 20, 30]))

fig = px.scatter_geo(df, lat="lat", lon="lon")  
fig.show()   

Customize further by setting map layers, zoom/pan constraints, marker size and more. Plotly can also plot tabular data joined to Shapefiles through geographic Choropleth maps. Geographic context helps uncover location-based patterns.

Sharing and Exporting

After creating insightful scatter plots, easily share them with collaborators by exporting to static files.

To save charts as images, use:

fig = px.scatter(...) # create figure
fig.write_image("chart.png")

While for interactive web-based charts:

fig.write_html(‘chart.html‘)

Share these exported HTML and image files as stand-alone chart representations supporting zoom, export, and more functionality.

Dashboards also help arrange multiple charts in views for coordinated analysis. Plotly figures integrate seamlessly with Dash dashboard frameworks.

Interactive Exploration

Where Plotly charts truly excel is interactive exploratory data analysis with Jupyter Notebook environments. Here, charts update in response to adjustments like:

• View mode toggles (zoom, pan, select, lasso)
• Slider filters on data ranges
• Selectors and buttons to emphasize data subsets
• Linked brushing across multiple charts

This interactivity brings data exploration to life, uncovering insights that static charts may miss.

Plotly figures also catch errors during manipulation to prevent crashes unlike Matplotlib plots. And chart persistence frees you to focus on analysis rather than redraw plots.

I encourage you to analyze the featured examples in a Jupyter Notebook to fully experience interactive Plotly exploration.

Key Takeaways

In this comprehensive 2600+ word guide, we covered how to:

• Quickly construct informative scatter plots with Plotly Express
• Customize plots through styling, statistical aggregation, animation and more
• Add interactivity for engaging, personalized chart exploration
• Access Plotly Graph Objects for advanced customization
• Visualize geographic data through maps
• Share and export static Plotly charts over HTML and images
• Utilize chart interactivity for insights in Jupyter Notebook environments

With minimal code, Plotly Express allows anyone to build beautiful, customized data visualizations for analysis. Combined with the full Plotly API, you can construct reusable charts that offer deep insights into complex datasets.

I hope you found this guide helpful for mastering scatter plots with Plotly Express! Let me know if you have any other questions.