Pandalar DataFrame'den ısı haritası oluşturma

Python'un Pandas paketinden oluşturulmuş bir veri çerçevem ​​var. Pandas paketinden DataFrame kullanarak nasıl ısı haritası oluşturabilirim?

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

İstersiniz 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()

Bu şunu verir:

Bugün buna bakan insanlar için, buradaheatmap() belgelendiği gibi Seaborn'u tavsiye ederim .

Yukarıdaki örnek şu şekilde yapılacaktır:

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)

%matplotlibAşina olmayanlar için bir IPython sihirli işlevi nerede .

Her söz için bir grafiğe ihtiyacınız yoksa ve değerleri bir tablo biçiminde temsil etmek için renk eklemekle ilgileniyorsanız style.background_gradient(), pandalar veri çerçevesi yöntemini kullanabilirsiniz . Bu yöntem, örneğin JupyterLab Notebook'ta pandalar veri çerçevelerini görüntülerken görüntülenen HTML tablosunu renklendirir ve sonuç, elektronik tablo yazılımında "koşullu biçimlendirme" kullanımına benzer:

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

Ayrıntılı kullanım için, lütfen daha önce aynı konuda verdiğim daha ayrıntılı yanıta ve pandalar belgelerinin stil bölümüne bakın .

Yararlı sns.heatmapapi burada . Parametreleri kontrol edin, çok sayıda var. Misal:

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)

Bir Pandas DataFrame'den etkileşimli bir ısı haritası istiyorsanız ve bir Jupyter dizüstü bilgisayarı çalıştırıyorsanız, etkileşimli Widget Clustergrammer-Widget'ı deneyebilirsiniz, burada NBViewer'daki etkileşimli not defterine bakın , dokümantasyon buradan

Daha büyük veri kümeleri için, geliştirme aşamasında olan Clustergrammer2 WebGL widget'ını deneyebilirsiniz (örnek not defteri burada )

Lütfen yazarlarının seabornyalnızca kategorik veri çerçeveleriyle çalışmak istediklerini seaborn.heatmap unutmayın. Genel değil.

Dizininiz ve sütunlarınız sayısal ve / veya tarih saat değerleriyse, bu kod size iyi hizmet edecektir.

Matplotlib ısı haritalama işlevi , endeksler yerine bölmelerpcolormesh gerektirir , bu nedenle veri çerçevesi endekslerinizden kutular oluşturmak için bazı süslü kodlar vardır (dizininiz eşit aralıklı olmasa bile!).

Gerisi basitçe np.meshgridve 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)

Kullanarak arayın heatmap(df)ve kullanarak görün plt.show().