Loading Data with Pandas

Plotly Express expects its data in a pandas DataFrame. If you've never used pandas before, that sentence might sound intimidating — but a DataFrame is just a table, and you only need to know a handful of operations before you can make every chart in this course.

This page is the just-enough pandas tutorial. We will not turn you into a pandas expert; we will get you fluent enough to feed Plotly Express.

What is a DataFrame?

A DataFrame is a table in memory. It has:

• Rows — usually one per observation (one country, one transaction, one student).
• Columns — named, typed fields (e.g., country, year, gdpPercap).
• An index — row labels, usually just 0, 1, 2, ... by default.

If you've used Excel, a DataFrame is roughly "one worksheet, with named column headers."

That prints a nicely formatted table. df.columns lists the column names. len(df) gives the number of rows.

Three ways data gets into a DataFrame

For this course, you'll see data arrive in three ways:

1. Built-in dataset. Plotly Express ships with several classic datasets:

   df = px.data.gapminder()    # life-expectancy & GDP
   df = px.data.iris()         # flower measurements
   df = px.data.tips()         # restaurant tipping
   df = px.data.stocks()       # daily stock prices

2. Hand-built dictionary. Useful for tiny illustrative examples:

   df = pd.DataFrame({"x": [1, 2, 3], "y": [4, 5, 6]})

3. A CSV (or Excel) file. The real-world case:

   df = pd.read_csv("sales.csv")

   In your own work this is the most common pattern.

For this course, we'll mostly use options 1 and 2, because no file uploads are needed in the browser runtime.

Peeking at a DataFrame

When you receive a DataFrame, your first instinct should be to look at it. Pandas provides a few essential methods:

Every analyst, every time they load a new dataset, runs some combination of df.head(), df.shape, df.columns, and df.describe(). Build the habit.

Selecting a column

To work with a single column, use square brackets:

df["lifeExp"]   # the lifeExp column, as a Series

You can also use dot notation if the column name is a valid Python identifier: df.lifeExp. Bracket notation is more universal — use it.

Filtering rows

Plotly Express works on whatever you pass it, so filtering before plotting is a common pattern. There are two ways to filter:

Boolean indexing

df_2007 = df[df["year"] == 2007]
df_rich = df[df["gdpPercap"] > 30000]
df_both = df[(df["year"] == 2007) & (df["gdpPercap"] > 30000)]

The & (and) and | (or) operators combine conditions. You must wrap each condition in parentheses — that's a Python operator- precedence quirk that trips up everyone exactly once.

The .query() method

A more readable alternative for simple filters:

df.query("year == 2007")
df.query("year == 2007 and gdpPercap > 30000")

You will see both styles in the wild. Pick whichever reads better to you in context.

Sorting

Sort by a column with sort_values:

df.sort_values("gdpPercap", ascending=False)

This is invaluable before charting. A bar chart sorted by value is almost always more readable than the same chart in alphabetical order.

Notice how much more useful the bar chart is when sorted by value — the eye reads "ranking" instantly.

Group + aggregate (just a peek)

A common pattern is to summarize a DataFrame before plotting: "average GDP per continent," "total sales per region," etc. The pandas pattern is groupby + an aggregation:

avg_by_continent = (
    df.query("year == 2007")
      .groupby("continent")["lifeExp"]
      .mean()
      .reset_index()
)

reset_index() is the magic that turns the grouped result back into a normal DataFrame so Plotly Express can consume it.

"Tidy" data: the secret to easy plotting

There's one big principle that will save you endless frustration: Plotly Express prefers tidy (long) data.

Tidy data follows three rules:

1. Each variable is a column.
2. Each observation is a row.
3. Each cell is a single value.

A common non-tidy layout looks like:

This is "wide" — years are columns. To plot it with Plotly Express, you almost always want to reshape it to long:

The tool to do that is df.melt(...):

This wide → long reshape pattern is one of the most common moves in real visualization work. Don't worry about memorizing melt() — when you need it, you'll look it up. Just recognize when your data is wide and Plotly Express is complaining.

Check your understanding