Hacer un mapa de calor a partir de pandas DataFrame

Tengo un marco de datos generado a partir del paquete Pandas de Python. ¿Cómo puedo generar un mapa de calor usando DataFrame del paquete pandas?

import numpy as np 
from pandas import *

Index= ['aaa','bbb','ccc','ddd','eee']
Cols = ['A', 'B', 'C','D']
df = DataFrame(abs(np.random.randn(5, 4)), index= Index, columns=Cols)

>>> df
          A         B         C         D
aaa  2.431645  1.248688  0.267648  0.613826
bbb  0.809296  1.671020  1.564420  0.347662
ccc  1.501939  1.126518  0.702019  1.596048
ddd  0.137160  0.147368  1.504663  0.202822
eee  0.134540  3.708104  0.309097  1.641090
>>> 

Quieres matplotlib.pcolor:

import numpy as np 
from pandas import DataFrame
import matplotlib.pyplot as plt

index = ['aaa', 'bbb', 'ccc', 'ddd', 'eee']
columns = ['A', 'B', 'C', 'D']
df = DataFrame(abs(np.random.randn(5, 4)), index=index, columns=columns)

plt.pcolor(df)
plt.yticks(np.arange(0.5, len(df.index), 1), df.index)
plt.xticks(np.arange(0.5, len(df.columns), 1), df.columns)
plt.show()

Esto da:

Para las personas que miran esto hoy, recomendaría el Seaborn heatmap()como se documenta aquí .

El ejemplo anterior se haría de la siguiente manera:

import numpy as np 
from pandas import DataFrame
import seaborn as sns
%matplotlib inline

Index= ['aaa', 'bbb', 'ccc', 'ddd', 'eee']
Cols = ['A', 'B', 'C', 'D']
df = DataFrame(abs(np.random.randn(5, 4)), index=Index, columns=Cols)

sns.heatmap(df, annot=True)

¿Dónde %matplotlibhay una función mágica de IPython para aquellos que no están familiarizados?

Si no necesita un gráfico por decir, y simplemente está interesado en agregar color para representar los valores en un formato de tabla, puede usar el style.background_gradient()método del marco de datos de pandas. Este método da color a la tabla HTML que se muestra al visualizar los marcos de datos de pandas en, por ejemplo, el JupyterLab Notebook y el resultado es similar al uso de "formato condicional" en el software de hoja de cálculo:

import numpy as np 
import pandas as pd


index= ['aaa', 'bbb', 'ccc', 'ddd', 'eee']
cols = ['A', 'B', 'C', 'D']
df = pd.DataFrame(abs(np.random.randn(5, 4)), index=index, columns=cols)
df.style.background_gradient(cmap='Blues')

Para un uso detallado, consulte la respuesta más elaborada que proporcioné sobre el mismo tema anteriormente y la sección de estilo de la documentación de pandas .

sns.heatmapApi útil está aquí . Mira los parámetros, hay un buen número de ellos. Ejemplo:

import seaborn as sns
%matplotlib inline

idx= ['aaa','bbb','ccc','ddd','eee']
cols = list('ABCD')
df = DataFrame(abs(np.random.randn(5,4)), index=idx, columns=cols)

# _r reverses the normal order of the color map 'RdYlGn'
sns.heatmap(df, cmap='RdYlGn_r', linewidths=0.5, annot=True)

Si desea un mapa de calor interactivo de un Pandas DataFrame y está ejecutando un cuaderno Jupyter, puede probar el widget interactivo Clustergrammer-Widget , vea el cuaderno interactivo en NBViewer aquí , la documentación aquí

Y para conjuntos de datos más grandes, puede probar el widget WebGL de Clustergrammer2 en desarrollo (cuaderno de ejemplo aquí )

Tenga en cuenta que los autores de seabornsolo quieren seaborn.heatmap trabajar con marcos de datos categóricos. No es general.

Si su índice y columnas son valores numéricos y / o de fecha y hora, este código le servirá bien.

La función de mapeo de calor de Matplotlib pcolormeshrequiere bins en lugar de índices , por lo que hay un código elegante para construir bins a partir de los índices de su marco de datos (¡incluso si su índice no está espaciado uniformemente!).

El resto es simple np.meshgridy plt.pcolormesh.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

def conv_index_to_bins(index):
    """Calculate bins to contain the index values.
    The start and end bin boundaries are linearly extrapolated from 
    the two first and last values. The middle bin boundaries are 
    midpoints.

    Example 1: [0, 1] -> [-0.5, 0.5, 1.5]
    Example 2: [0, 1, 4] -> [-0.5, 0.5, 2.5, 5.5]
    Example 3: [4, 1, 0] -> [5.5, 2.5, 0.5, -0.5]"""
    assert index.is_monotonic_increasing or index.is_monotonic_decreasing

    # the beginning and end values are guessed from first and last two
    start = index[0] - (index[1]-index[0])/2
    end = index[-1] + (index[-1]-index[-2])/2

    # the middle values are the midpoints
    middle = pd.DataFrame({'m1': index[:-1], 'p1': index[1:]})
    middle = middle['m1'] + (middle['p1']-middle['m1'])/2

    if isinstance(index, pd.DatetimeIndex):
        idx = pd.DatetimeIndex(middle).union([start,end])
    elif isinstance(index, (pd.Float64Index,pd.RangeIndex,pd.Int64Index)):
        idx = pd.Float64Index(middle).union([start,end])
    else:
        print('Warning: guessing what to do with index type %s' % 
              type(index))
        idx = pd.Float64Index(middle).union([start,end])

    return idx.sort_values(ascending=index.is_monotonic_increasing)

def calc_df_mesh(df):
    """Calculate the two-dimensional bins to hold the index and 
    column values."""
    return np.meshgrid(conv_index_to_bins(df.index),
                       conv_index_to_bins(df.columns))

def heatmap(df):
    """Plot a heatmap of the dataframe values using the index and 
    columns"""
    X,Y = calc_df_mesh(df)
    c = plt.pcolormesh(X, Y, df.values.T)
    plt.colorbar(c)

Llámelo usando heatmap(df)y véalo usando plt.show().