An Intro to Python's Plotly Express
Tags: datascience, python, tutorial, programming
Published: 2023-05-27 22:14:56


With Plotly, you can control almost every aspect of your graph layout, from setting the x and y labels to configuring the thickness of the plot lines. But this often results in verbose code. Plotly Express takes away that verbosity. 

### What is Plotly Express?

Plotly Express (also called PX) is a concise, high-level Python library for data visualization. A sub-module of the larger Plotly library, `plotly.express` is a wrapper for `plotly.py`, providing a more simplified and intuitive interface for exploring data and generating charts. 

Plotly Express reduces the amount of code needed to create basic charts. A graph you would create with a single line of code in Plotly Express would take between [5 and a 100 times](https://plotly.com/python/plotly-express/) as many lines of code to create in Plotly.py.

Plotly Express has more than 30 functions — `scatter`, `line`, `bar`, `choropleth`, `sunburst`, `histogram`, etc — for creating different types of figures. And they're all designed to be as simple to remember as possible. What’s more? Plotly Express comes with plenty of built-in datasets that you can use for your learning and experiments. 

We’ll be exploring `gapminder()`, a dataset of World Bank Indicators, such as life expectancy and GDP per capita, for more than 170 countries (from 1998–2007). 

(To learn more about other built-in datasets — such as `iris`, a dataset of flowers, and `tips`, a restaurant dataset — you can read the [data package documentation](https://plotly.com/python-api-reference/generated/plotly.express.data.html).) 

In this article, we’ll focus on learning how to create various colorful and interactive graphs — all in single function calls! —with Plotly Express using *gapminder*.

### Installation

First, install Plotly.py if you don't have it already. You can install Plotly with pip:

`python -m pip install plotly` 

or with conda:

`conda install -c plotly`

### Plotting simple graphs with Plotly Express

Start by importing `plotly.express` (usually as `px`). Once you do this, you’ll have access to all the plotting functions, built-in datasets, and colorscales in the Plotly ecosystem. 

For our first example, let's make a scatter plot showing the population and GDP per capita of African countries for 2007 (using our gapminder dataset):

```
import plotly.express as px
africa_data = px.data.gapminder().query("continent=='Africa'").query("year==2007")
fig = px.scatter(africa_data, x="gdpPercap", y="pop")
fig.show()
```

![A scatter plot of Africa's population vs GDP per Capita](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/p9h2n35gsaxlneq9wcd5.png)

We called `gapminder()` and passed it two column names, “continent” and “year”, using the `query` argument. This tells PX that we want data only for a specific continent and year. We assigned the object returned to the variable "africa_data". In the next line, we called the scatter function, passed it "africa_data", and set the x values to "gdpPercap" and the y values to "pop", both of which are column names in gapminder. The resulting image is a figure showing the population and GDP per capita of every African country in 2007, with each dot representing a country. 

Our graph doesn’t look very meaningful yet. To improve it, we’ll add `colors` to the dots to make the countries distinguishable. We’ll also give our graph a title:

```
import plotly.express as px
-- snip --
fig = px.scatter(africa_data, x=“gdpPercap”, y=“pop”, color=“country”, title=“Africa’s Population and GDP Per Capita”)
fig.show()
```

![A scatter plot of Africa's Population vs GDP per Capita, with a default color for each country](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/5moizqys1x28t4gp24u1.png)

We added the arg `color` and passed “country” to it. PX handled the rest of the detail, such as assigning a default color to each country and creating a legend. Now our graph looks more meaningful.

Plotly Express offers you a lot of customization options for modifying your data series. For instance, to make our graph easier to read and a bit more understandable, let’s increase the size of the dots by the population of each country:

```
import plolty.express as px
-- snip -- 
 fig = px.scatter(africa_data, x=“gdpPercap”, y=“pop”, color=“country”, size=“pop”, size_max=50, hover_name=“country”, title=“Africa’s Population and GDP Per Capita”)
fig.show()
```

![A scatter plot showing Africa's population and GDP per Capita. Each dot is scaled according to the size of the population](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/zzpuic19njhjbbum8f9t.png)

We passed “pop” to `size` so that the more the population of a county, the bigger its dot. We then set the maximum size of the dot to 50. (Size 50 works fine on my screen; a higher or lower value may be better on yours.) We also added `hover_name` to the plot and set it to “country” so that we can easily identify which dot is which country. 

*Note: The graph is interactive even without `hover_name`: mousing over any dot would reveal the country, population size, and GDP per capita*. 

The plot looks great now. But we can make it look better by using descriptive names for the x and y axes. We currently have “gdpPercap” and “pop" — both of which, to be honest, are very unsightly. Fortunately, PX lets you set your own label names, using the `labels` arg. It's basically a `dict` in which the `key` is the original label and the `value` is the label you want to replace it with.

```
import plotly.express as px
-- snip --
 fig = px.scatter(africa_data, x=“gdpPercap”, y=“pop”, color=“country”, size=“pop”, size_max=50, hover_name=“country”, title=“Africa's Population and GDP Per Capita", labels={“pop”: “Population”, “gdpPercap”: “GDP per Capita”, “lifeExp”: “Life Expectancy”})
fig.show()
```

![A scatter plot of Africa's population and GPP per Capita, with formatted labels](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/t970u5zj5qg6bs5jvp18.png)

We now have a nicer-looking graph with labels that are easy to read and understand. Using descriptive names as labels is good accessibility practice. 

### Plotting an animated choropleth map with one function call

Because gapminder is geographic data, we can further experiment with it by creating an animated choropleth map using PX’s `choropleth()`function and `animation_frame` argument. To make our map more colorful and interactive, we’ll use the entire gapminder dataset, not just for a specific continent and year:

```
import plotly.express as px
df = px.data.gapminder()
fig= px.choropleth(df, locations="iso_alpha", color="lifeExp", hover_name="country", animation_frame="year",
              color_continuous_scale="Plasma_r", range_color=[40, 70], title="Gapminder Life Expectancy", projection="natural earth")
fig.show()
```

![An animated choropleth map of global life expectancy, with the animation frame set from 1956 to 2007](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/66ijmwnj7n4jbcvstevg.png)

Let's analyze our code line by line:

 First, notice that we’re now using the entire gapminder dataset, which we defined as “df.”  

We then called `choropleth`, passed “iso_alpha” (the country-codes column in gapminder) to the `locations` arg, and mapped `color` to “lifeExp.” We dropped the “pop” variable because it's hard for choropleth to handle two variables; it's better suited for mapping one variable at a time (in our case “lifeExp”) across a geographic area, showing the variable's level of intensity or unevenness throughout the given regions. 

We added `color_continuous_scale`, which is a PX arg that uses colors to represent ***continuous*** **data** — the same way we use the x and y axes to represent **continuous values**. Next, we set our `colorscale` arg to Plasma and added r at the end. This tells PX to reverse the order of the colorscale. Blue now represents a higher intensity, instead of the other way around. (You can omit the "r" if you like the default order of the colorscale; I just prefer mine reversed.)

They're at least 94 built-in color names you can use to set the `color_continuous_scale` arg. Here's the code to see a list of them:
```
import plotly.express as px
all_color_names = px.colors.named_colorscales()
print(all_color_names)
```
Next, we included the `range_color` arg, which handles the range of our colorscale, as shown in the `colorbar` beside our map. 

Finally, we passed “natural earth” to `projection.` *Projection* is a PX arg that draws flattened geo maps according to the type you specify. For a full list of available projection types, check Plotly’s [map configuration and styling](https://plotly.com/python/map-configuration/) page, under the subheading “Map Projections.” 

Congratulations! You’ve learned the fundamentals of Plotly Express. You created a basic scatter plot using the built-in gapminder dataset. You added colors to the little points on the plot and scaled their sizes according to the population of each country. You also added descriptive names and an informative title to make your figure more readable and easier to understand. You then produced a colorful, animated, choropleth map. Best of all, you created all of these with just single-line function calls!

**Note**: The images in this article are static. But if you type in the code snippets correctly and run them, PX should display an interactive graph on your default web browser. You can also write your figure directly into an HTML file, which can be viewed interactively on a web browser. Just replace `fig.show()` with `fig.write_html(“path_to_file//filename.html”)` — although the resulting file from this method is usually large, up to 5Mb.

For a detailed documentation on how to use the write_html function — including how to control the size of the resulting file — just run the `help` command, like this: 
```
import plotly.graph_objects as go
help(go.Figure.write_html)
```
That’s all for an intro to the short and sweet Plotly Express. 
For a more detailed discussion on the Plotly Express module and what makes it special, read the [official release article](https://medium.com/plotly/introducing-plotly-express-808df010143d) from 2019. 

Ready to dive in and give PX a spin? Browse through [this gallery of examples](https://plotly.com/python/plotly-express/) of some of the things you can do with PX or check the [reference documentation](https://plotly.com/python-api-reference/plotly.express.html).

Thank you so much for reading!😊 Would love to hear about the amazing things you plan to do with Plotly Express.