如何用Python创建不等尺寸方块的股票收益热图（类似Finviz样式）？

Great question! Creating a stock heatmap similar to Finviz's interactive map is a popular task for financial data visualization, and you’re already off to a strong start considering Plotly’s unequal block size heatmaps. Let’s walk through more efficient approaches so you don’t have to reinvent the wheel or piece together dozens of small heatmaps with Dash.

1. Refine Your Plotly Approach (No Need to Split into Small Heatmaps) #

Plotly’s "Heatmap with Unequal Block Sizes" can directly handle the Finviz-style layout—you just need to leverage custom axis scaling and block dimension parameters. Instead of splitting into separate heatmaps, you can define:

• Grouped categories: Use major axes for sectors (e.g., Technology, Financials) and minor axes for individual stocks within each sector.
• Custom block sizes: Adjust dx/dy in go.Heatmap or use categorical arrays with explicit spacing to control the width/height of each stock’s block (e.g., scaling block size to market cap).

Here’s a quick simplified example to illustrate:

import plotly.graph_objects as go
import pandas as pd

# Sample data: stocks with sector, market cap, and daily return
data = pd.DataFrame({
    'Stock': ['AAPL', 'MSFT', 'JPM', 'BAC'],
    'Sector': ['Tech', 'Tech', 'Financials', 'Financials'],
    'MarketCap': [2.8e12, 2.4e12, 400e9, 300e9],
    'Return': [1.2, 0.8, -0.5, -0.3]
})

# Map sectors to x positions, scale block width by market cap
sector_x = {'Tech': 0, 'Financials': 2}
stock_widths = data['MarketCap'] / data['MarketCap'].max() * 1.5

# Create heatmap trace
fig = go.Figure(data=go.Heatmap(
    z=data['Return'],
    x=[sector_x[s] + w/2 for s, w in zip(data['Sector'], stock_widths)],
    y=[0]*len(data),
    dx=stock_widths,
    dy=1,
    colorscale='RdYlGn',
    text=data['Stock'],
    hoverinfo='text+z'
))

fig.update_layout(title='Stock Return Heatmap', xaxis_title='Sector', yaxis_visible=False)
fig.show()

This lets you control block sizes and grouping without splitting the visualization.

2. Use Squarify for Treemap-Style Heatmaps #

If you prefer a grid-like layout where block size corresponds to a metric (like market cap), the squarify library paired with Matplotlib or Plotly is a great fit. It calculates the coordinates of rectangular blocks to fit a given area, which you can color-code by return:

import squarify
import matplotlib.pyplot as plt

# Prepare data
sizes = data['MarketCap'].values
colors = plt.cm.RdYlGn([(r + 5)/10 for r in data['Return']])  # Normalize returns for color

plt.figure(figsize=(10, 6))
squarify.plot(sizes=sizes, label=data['Stock'], color=colors, alpha=0.8)
plt.title('Stock Return Heatmap (Market Cap Scaled)')
plt.axis('off')
plt.show()

This mimics Finviz’s size-scaled blocks and color-coded returns, and you can add interactivity by porting it to Plotly with plotly.express.treemap (though treemaps are nested, you can flatten them for a grid-like look).

3. Avoid Overcomplicating with Dash (Unless You Need Full Interactivity) #

While Dash is great for building dashboards, you don’t need to stitch together dozens of heatmaps. Instead, embed your single Plotly/Squarify visualization into a Dash app directly. If you need advanced interactivity (like filtering sectors on click), you can add callbacks to update the underlying data and redraw the plot—much more efficient than managing multiple heatmap components.

4. Are There Out-of-the-Box Tools? #

There’s no Python library that generates a Finviz-style heatmap with one line of code, but the methods above are robust and require minimal custom code. For even more control, you can use Bokeh’s Rect glyphs to manually draw each block with custom positions, sizes, and colors.

Final Takeaway #

You don’t need to build from scratch! Plotly’s unequal block heatmap or squarify with Matplotlib/Plotly will get you 90% of the way there, with far less complexity than splitting into small heatmaps. Add Dash only if you need to wrap the visualization in an interactive dashboard.

内容的提问来源于stack exchange，提问作者Troy D