5 Best Ways to Simultaneously Apply Color, Shape, and Size in Python Plotly Scatter Plots

by

💡 Problem Formulation: When visualizing multidimensional data, it’s often useful to represent different variables by altering the color, shape, and size of points within a scatter plot. For instance, using Python’s Plotly library, we might want to visualize a dataset where the ‘x’ and ‘y’ axes represent two metrics, point color correlates with a third metric, shape represents categories, and size indicates the magnitude of a fourth variable. This article details how to achieve this nuanced visual representation.

Method 1: Utilizing Plotly Express with Custom Data Arguments

The Plotly Express module in Plotly simplifies plot creation with concise functional calls. It accepts direct arguments for color, size, and symbol (shape), allowing the easy mapping of different dataset columns to these attributes. Here we’re using px.scatter() for creating a scatter plot.

Here’s an example:

import plotly.express as px
df = px.data.iris()  # Example dataset
fig = px.scatter(df, x='sepal_width', y='sepal_length', 
                 color='species', size='petal_length', symbol='species')
fig.show()

The output is a scatter plot with different colors, shapes, and sizes for points based on the species.

In this snippet, we have used the Iris dataset, mapping ‘sepal_width’ to the x-axis and ‘sepal_length’ to the y-axis. The data column ‘species’ determines both the color and the shape of the points, while ‘petal_length’ dictates their size. This introduces an immediate visual differentiation between the species, and the size variation gives an insight into the petal length distribution.

Method 2: Using Graph Objects for Granular Control

Plotly’s Graph Objects offer more control than Plotly Express, with a detailed interface for customizing the properties of the scatter plot. The go.Scatter() function is used here, where color, size, and symbol specifications can explicitly be set for each point individually if necessary.

Here’s an example:

import plotly.graph_objs as go
trace = go.Scatter(x=[1, 2, 3, 4],
                   y=[10, 11, 12, 13],
                   mode='markers',
                   marker=dict(
                       color=['red', 'blue', 'green', 'black'],
                       size=[10, 20, 30, 40],
                       symbol=['circle', 'square', 'diamond', 'cross']
                   ))
fig = go.Figure(data=trace)
fig.show()

The output is a scatter plot where each point has a unique color, shape, and size.

This code creates a highly customized scatter plot where each point is individually styled. The ‘color’, ‘size’, and ‘symbol’ attributes are lists that apply respective styles to the points, providing precise control over the visualization, which is ideal for conveying complex data stories.

Method 3: Animated Scatter Plot for Dynamic Visualization

An animated scatter plot in Plotly can show how data points evolve over time or another variable, such as date or category. By using the animation_frame and animation_group parameters in Plotly Express, you can add a temporal dimension to the scatter plot.

Here’s an example:

import plotly.express as px
df = px.data.gapminder()
fig = px.scatter(df, x='gdpPercap', y='lifeExp',
                 size='pop', color='continent',
                 hover_name='country', log_x=True, 
                 size_max=55, range_x=[100,100000], range_y=[25,90],
                 animation_frame='year', animation_group='country')
fig.show()

The output is an animated scatter plot that transitions through different years, showing the progression of GDP and life expectancy, differentiated by continent with varying population sizes.

This code leverages the ‘year’ column to create an animation frame for each year, effectively showing how GDP per capita and life expectancy have changed over time. Each country is represented by a bubble whose size reflects its population. This method is powerful for showing temporal changes and trends in data.

Method 4: Combining Multiple Traces for Layered Visualisations

Mixing multiple traces can create layered visualizations in a single plot. Each go.Scatter() instance can have different styling for color, size, and shape, which allows for the overlaying of distinct data groups on the same plot for comparison.

Here’s an example:

import plotly.graph_objs as go
trace1 = go.Scatter(x=[1, 2], y=[3, 4], mode='markers',
                    marker=dict(color='red', size=[10, 30], symbol='circle'))
trace2 = go.Scatter(x=[2, 3], y=[4, 5], mode='markers',
                    marker=dict(color='blue', size=[20, 40], symbol='square'))
fig = go.Figure()
fig.add_trace(trace1)
fig.add_trace(trace2)
fig.show()

The output is a scatter plot with two distinct sets of markers, each set having its own color, shape, and size properties.

The code illustrates the layering of two different traces on the same plot. This technique is useful when you want to compare two data sets side by side, with clear visual distinction provided by color, shape, and size variations.

Bonus One-Liner Method 5: Utilizing DataFrame Style Mapping

A DataFrame can include style columns that integrate directly into a Plotly scatter plot, using a one-liner with plotly.express.scatter. This method is a concise way of applying styling if your DataFrame is already organized with style-specific columns.

Here’s an example:

import plotly.express as px
df['color'] = ['red', 'blue', 'green', 'red']
df['size'] = [10, 20, 30, 40]
df['symbol'] = ['circle', 'square', 'diamond', 'cross']
fig = px.scatter(df, x='sepal_width', y='sepal_length',
                 color='color', size='size', symbol='symbol')
fig.show()

The output is a scatter plot with styles applied directly from the DataFrame’s ‘color’, ‘size’, and ‘symbol’ columns.

Adding style columns to the DataFrame can streamline the visualization code, making it cleaner and more intuitive. This one-liner approach is efficient when you have a DataFrame pre-configured with style attributes.

Summary/Discussion

  • Method 1: Plotly Express with Custom Data Arguments. Strengths: Concise syntax, quick to implement. Weaknesses: Less control over individual point styling.
  • Method 2: Graph Objects for Granular Control. Strengths: Highly customizable, fine-tuned control. Weaknesses: More verbose code, potentially overwhelming for simple plots.
  • Method 3: Animated Scatter Plot. Strengths: Represents temporal data excellently, dynamic and engaging. Weaknesses: Can be complex to set up, may require more data preparation.
  • Method 4: Combining Multiple Traces. Strengths: Allows comparison of different datasets, layered approach. Weaknesses: Needs careful management of traces, can become cluttered.
  • Bonus Method 5: DataFrame Style Mapping. Strengths: Extremely concise when DataFrame is prepared, clean integration of style and data. Weaknesses: Requires additional DataFrame preparation, may not be as flexible for ad-hoc styling changes.