web-dev-qa-db-fra.com

Créer un heatmap à partir de pandas DataFrame

J'ai une base de données générée à partir du paquet Pandas de Python. Comment puis-je générer un heatmap avec DataFrame à partir du paquet 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
>>>
pythonpandasdataframeheatmap
91
Curious

Tu veux matplotlib.pcolor:

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

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

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()
67
chthonicdaemon

Pour les personnes regardant cela aujourd'hui, je recommanderais le Seaborn heatmap() comme documenté ici .

L'exemple ci-dessus se ferait comme suit:

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)

Où %matplotlib _ est une fonction magique IPython pour les inconnus.

141
Brideau

Si vous n'avez pas besoin de tracé, et que vous souhaitez simplement ajouter de la couleur pour représenter les valeurs sous forme de tableau, vous pouvez utiliser la méthode style.background_gradient() du bloc de données pandas. . Cette méthode colorise la table HTML affichée lors de la visualisation de pandas trames de données dans, par exemple. le bloc-notes JupyterLab et le résultat est similaire à l'utilisation de la "mise en forme conditionnelle" dans un tableur:

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')

enter image description here

Pour une utilisation détaillée, veuillez vous reporter à la réponse plus élaborée que j'ai précédemment fournie sur le même sujet et à la section sur le style de la documentation de pandas .

39
joelostblom

Utile sns.heatmap api est ici . Vérifiez les paramètres, il y en a un bon nombre. Exemple:

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)

enter image description here

14
Brad Solomon

Si vous voulez une carte thermique interactive d'un Pandas DataFrame et que vous exécutez un bloc-notes Jupyter, vous pouvez essayer le widget interactif Clustergrammer-Widget , voir le bloc-notes interactif sur NBViewer - ici , documentation ici

enter image description here

Et pour de plus grands ensembles de données, vous pouvez essayer le développement en cours Clustergrammer2 Widget WebGL (exemple: bloc-notes ici )

1
Nick Fernandez

Veuillez noter que les auteurs de seaborn seulement veulentseaborn.heatmap Travaillent avec des cadres de données catégoriques. Ce n'est pas général.

Si votre index et vos colonnes sont des valeurs numériques et/ou datetime, ce code vous sera utile.

La fonction de cartographie thermique Matplotlib pcolormesh requiert des bacs au lieu de indices , il y a donc du code de fantaisie pour construire des bacs à partir de vos index de données (même si votre index n’est pas espacé de manière égale!).

Le reste est simplement np.meshgrid Et 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)

Appelez-le en utilisant heatmap(df) et visualisez-le en utilisant plt.show().

enter image description here

0
OrangeSherbet