Membuat peta panas dari pandas DataFrame

Saya memiliki kerangka data yang dihasilkan dari paket Pandas Python. Bagaimana saya bisa menghasilkan peta panas menggunakan DataFrame dari paket 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
>>> 

Anda ingin 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()

Ini memberi:

Bagi orang yang melihat ini hari ini, saya akan merekomendasikan Seaborn heatmap()seperti yang didokumentasikan di sini .

Contoh di atas akan dilakukan sebagai berikut:

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)

Di mana %matplotlibfungsi ajaib IPython untuk mereka yang tidak terbiasa.

Jika Anda tidak memerlukan plot per kata, dan Anda hanya tertarik untuk menambahkan warna untuk mewakili nilai dalam format tabel, Anda dapat menggunakan style.background_gradient()metode bingkai data pandas. Metode ini mewarnai tabel HTML yang ditampilkan saat melihat bingkai data panda di misalnya, Notebook JupyterLab dan hasilnya mirip dengan menggunakan "pemformatan bersyarat" di perangkat lunak spreadsheet:

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

Untuk penggunaan terperinci, silakan lihat jawaban yang lebih terperinci yang saya berikan pada topik yang sama sebelumnya dan bagian gaya dari dokumentasi panda .

sns.heatmapApi yang berguna ada di sini . Periksa parameternya, ada sejumlah bagus. Contoh:

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)

Jika Anda menginginkan peta panas interaktif dari Pandas DataFrame dan Anda menjalankan buku catatan Jupyter, Anda dapat mencoba Widget Clustergrammer-Widget interaktif, lihat buku catatan interaktif di NBViewer di sini , dokumentasi di sini

Dan untuk kumpulan data yang lebih besar Anda dapat mencoba widget Clustergrammer2 WebGL dalam pengembangan (contoh notebook di sini )

Harap dicatat bahwa penulis seabornhanya ingin seaborn.heatmap bekerja dengan kerangka data kategorikal. Ini tidak umum.

Jika indeks dan kolom Anda adalah nilai numerik dan / atau tanggal waktu, kode ini akan membantu Anda dengan baik.

Fungsi pemetaan panas Matplotlib pcolormeshmembutuhkan bins, bukan indeks , jadi ada beberapa kode keren untuk membuat bins dari indeks dataframe Anda (bahkan jika indeks Anda tidak berjarak sama!).

Sisanya sederhana np.meshgriddan 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)

Sebut saja menggunakan heatmap(df), dan lihat menggunakan plt.show().