28. Pandas Styling

By Bernd Klein. Last modified: 12 Feb 2025.

Introduction

Pure text is straightforward and easy to read, but it can sometimes lack emphasis and clarity, especially in complex or lengthy content. On the other hand, text with highlights, different fonts, and colors helps guide the reader’s attention, emphasize key points, and improve readability. Using visual distinctions like bold, italics, and color coding can make important information stand out, enhance comprehension, and improve user engagement. However, overuse of these elements can create clutter and reduce readability, so balance is key.

This was an example of a pure text or matter-of-fact style as we usually find it in serious textbooks. In contrast, you might encounter a more engaging style like this:

Pure text is straightforward and easy to read, but it can sometimes lack emphasis and clarity, especially in complex or lengthy content.
On the other hand, text with highlights, different fonts, and 🎨 colors helps guide the reader’s attention, emphasize key points, and improve readability.
✅ Using bold, italics, and 🟢 color coding can make important information stand out, enhance comprehension, and improve user engagement.
⚠️ However, overuse of these elements can create clutter and reduce readability, so balance is key!

Now, you might already have an idea about the focus of this chapter in our Pandas tutorial. Let's shift our attention to Python and Pandas: Just as we can enhance and structure text to improve clarity and presentation, we can apply similar principles to a DataFrame, making it more readable and visually appealing without altering its raw data.

In programming—including Python development—a fundamental best practice is to separate raw data (logic) from its presentation (styling or rendering). This principle applies across various domains, from web development to data science and backend engineering.

In Pandas, we adhere to this principle by keeping raw data independent of its presentation. This ensures that the data remains accurate, computationally usable, and easily formatted when needed, without altering its underlying structure.

Why Separate Data from Presentation in Pandas?

• Preserves Data Integrity
  The underlying numerical values remain unchanged, preventing rounding errors or data corruption.

  Example: Keeping a value as 1234.5678 instead of storing it as a formatted string "1,234.57 USD".

• Ensures Computation Compatibility
  Operations like summing, averaging, or statistical analysis require pure numerical data.

  Example: If we store "$100.50" as a string, Pandas can't calculate total sales correctly.

• Allows Flexible Presentation
  Formatting can be applied dynamically for different use cases (reports, dashboards, user-specific views).

  Example: Showing "50%" for display but keeping it as 0.5 for calculations.

• Enhances Maintainability
  If display requirements change (e.g., from USD to EUR), only the styling logic needs to be updated, not the actual data.

Live Python training

Enjoying this page? We offer live Python training courses covering the content of this site.

See our Python training courses

See our Machine Learning with Python training courses

The .style property

Pandas provides a powerful .style property that allows you to format and style DataFrames in a visually appealing way, especially useful for Jupyter Notebooks and reports. The .style property in Pandas enables dynamic formatting and visualization without changing the raw data. It improves readability with number formatting, color gradients, and highlights while keeping computations intact.

Basis Formatting with .format

First, let's take a look at the format method .style of Pandas in the following example. The format method in Pandas .style is used to customize the display of DataFrame values without modifying the underlying data.

The following example demonstrates how to format numerical values in a DataFrame by setting column B to display only two decimal places:

import pandas as pd

df = pd.DataFrame({'A': [1, 2, 3], 'B': [4.1234, 5.5678, 6.91011]})

# Apply formatting
styled_df = df.style.format({'B': "{:,.2f}"})  # Format column 'B' to 2 decimal places
styled_df

Other formatting possibilities:

Common Use Cases:

• "{:,.2f}" → Thousands separator + 2 decimals (1,234.56)
• "{:.1%}" → Percentage (12.3%)
• "{:.3e}" → Scientific notation (1.235e+02)

The data remains numerical, but is displayed in a formatted way.

Before exploring another example of format, let's first examine the wrong approach to understand why mixing logic and rendering is a bad practice. By seeing this mistake in action, you'll better appreciate the importance of keeping data processing and presentation separate:

df = pd.DataFrame({'Price': ['$1,234.57', '$9,876.43'], 'Discount': ['15%', '25%']})
df

This is bad because:

• The values are stored as strings instead of numeric types.
• You cannot perform calculations like summing, averaging, or sorting.
• Formatting (currency symbols, percentage signs) is mixed with data, violating the separation of data and presentation principle.

Now, the correct way with style.format:

df = pd.DataFrame({'Price': [1234.57, 9876.43], 'Discount': [0.15, 0.25]})

# Apply formatting only for display (keeping numbers intact)
df.style.format({'Price': '${:,.2f}', 'Discount': '{:.0%}'})

This is a lot better:

• Price column remains a float (e.g., 1234.57), but displays as "$1,234.57".
• Discount column remains a float (e.g., 0.15), but displays as "15%".

Highlighting Maximum Values

The following example demonstrates how to highlight the maximum value in each column using highlight_max(), making key values stand out visually.

import pandas as pd

df = pd.DataFrame({
    'First Name': ['Alice', 'Bob', 'Charlie', 'David', 'Emma'],
    'Weight (kg)': [68, 85, 74, 90, 62],
    'Height (cm)': [165, 180, 175, 185, 160],
    'IQ': [120, 135, 110, 145, 125]
})

# Apply styling to highlight the maximum value in each column
styled_df = df.style.highlight_max(axis=0, color='lightgreen')

styled_df

In the previous example, we highlighted the maximum value within each column. However, highlighting the maximum values in each row wouldn’t be meaningful due to the inhomogeneous nature of the data — comparing a name, weight, height, and IQ within a single row isn't logical.

To demonstrate a case where row-wise highlighting is useful, let's explore a more suitable example. With the parameter axis, we can determine, if we want to highlight row-wise (axis=1) or column-wise (axis=0).

import pandas as pd

df = pd.DataFrame({
    'Monday': [8.5, 7.2, 9.0, 6.8, 8.3],
    'Tuesday': [7.4, 8.1, 6.5, 9.2, 7.0],
    'Wednesday': [8.0, 9.3, 7.7, 8.1, 6.9],
    'Thursday': [6.2, 8.4, 9.1, 7.3, 8.5],
    'Friday': [7.3, 6.8, 8.2, 7.6, 9.1]
}, index=['Alice', 'Bob', 'Charlie', 'David', 'Emma'])

# Apply styling to highlight the maximum value in each row
# (each person's longest workday)
styled_df = df.style.highlight_max(axis=1, color='orange')

styled_df

Now, we highlight the longest workday per day with axis=0:

import pandas as pd

df = pd.DataFrame({
    'Monday': [8.5, 7.2, 9.0, 6.8, 8.3],
    'Tuesday': [7.4, 8.1, 6.5, 9.2, 7.0],
    'Wednesday': [8.0, 9.3, 7.7, 8.1, 6.9],
    'Thursday': [6.2, 8.4, 9.1, 7.3, 8.5],
    'Friday': [7.3, 6.8, 8.2, 7.6, 9.1]
}, index=['Alice', 'Bob', 'Charlie', 'David', 'Emma'])

styled_df = df.style.highlight_max(axis=0, color='orange')

styled_df

Applying a Gradient

The .background_gradient() method applies a color gradient to each cell based on its value using a specified colormap (cmap). The logic behind it involves normalizing the data and then mapping it to a color scale.

df.style.background_gradient(cmap='Blues')

Step-by-Step Logic Behind the Gradient Coloring:

1. Normalize Values
   • Pandas scales the values in each column between 0 and 1.
   • The minimum value becomes 0 (lightest color) and the maximum value becomes 1 (darkest color).

2. Apply the Colormap (cmap='Blues')

   • A matplotlib colormap (like "Blues") is used to assign colors based on the normalized values.
   • Smaller values get lighter shades of blue.
   • Larger values get darker shades of blue.

3. Render the Colors

   • The background color for each cell is set using the corresponding color from the colormap.

By default, background_gradient() normalizes values column-wise (axis=0). To scale row-wise, you need to set axisto 1:

df.style.background_gradient(cmap='Blues', axis=1)

You can experiment with other cmap-values:

• 'Blues' → Shades of blue (good for clarity)
• 'Greens' → Shades of green (eco-friendly, positive impact)
• 'Oranges' → Shades of orange (warm tones)
• 'Purples' → Shades of purple (stylish, artistic)
• 'Reds' → Shades of red (intensity, urgency)
• 'Greys' → Shades of grey (neutral, good for subtle visual effects)

Diverging Colormaps are great for highlighting deviations from a central value (e.g., positive vs. negative changes).

• 'coolwarm' → Blue to red gradient (good for highlighting differences)
• 'RdBu' → Red to blue (opposite extremes)
• 'PiYG' → Pink to green (aesthetic, alternative to red/blue)
• 'BrBG' → Brown to green (earthy tones, good for contrasts)

Multi-Color & Fancy Colormaps provide unique and vibrant effects.

• 'viridis' → Yellow-green-blue (colorblind-friendly, widely used in data visualization)
• 'plasma' → Purple-red-yellow (high contrast, stands out)
• 'magma' → Dark purple-orange-yellow (dramatic, good for high-impact visuals)
• 'cividis' → Blue-yellow (colorblind-friendly alternative to viridis)

Here is an example using cmap='cividis':

import pandas as pd
import numpy as np

data = {
    'January': [5000, -2000, 3000, -1000, 2600],
    'February': [-1500, 4000, -2500, 500, -1100],
    'March': [3000, -1800, 6200, -700, 1000],
    'April': [-2200, 5000, -1200, 1000, 3500]
}

index = ['Nimbus Corp', 'Quantum Dynamics', 'Aurora Ventures', 
         'Vertex Solutions', 'Orion Enterprises']

df = pd.DataFrame(data, index=index)

# Apply styling with 'cividis' colormap
styled_df = df.style.background_gradient(cmap='cividis')

styled_df

Applying Bar Charts Inside Cells

The .style.bar() method adds bar charts within the cells to visually represent the values. It helps quickly compare work hours per person (row-wise) or per day (column-wise).

import pandas as pd

df = pd.DataFrame({
    'Monday': [8.5, 5.2, 9.8, 6.1, 7.3],
    'Tuesday': [6.4, 8.7, 7.1, 9.0, 5.6],
    'Wednesday': [7.8, 9.5, 5.9, 8.3, 6.7],
    'Thursday': [5.6, 7.2, 9.3, 6.8, 8.9