Wie man Cluster von gestapelten Bars mit Python (Pandas) hat

Ich habe es geschafft, dasselbe mit Pandas und Matplotlib-Subplots mit grundlegenden Befehlen zu tun.

Hier ist ein Beispiel:

fig, axes = plt.subplots(nrows=1, ncols=3)

ax_position = 0
for concept in df.index.get_level_values('concept').unique():
    idx = pd.IndexSlice
    subset = df.loc[idx[[concept], :],
                    ['cmp_tr_neg_p_wrk', 'exp_tr_pos_p_wrk',
                     'cmp_p_spot', 'exp_p_spot']]     
    print(subset.info())
    subset = subset.groupby(
        subset.index.get_level_values('datetime').year).sum()
    subset = subset / 4  # quarter hours
    subset = subset / 100  # installed capacity
    ax = subset.plot(kind="bar", stacked=True, colormap="Blues",
                     ax=axes[ax_position])
    ax.set_title("Concept \"" + concept + "\"", fontsize=30, alpha=1.0)
    ax.set_ylabel("Hours", fontsize=30),
    ax.set_xlabel("Concept \"" + concept + "\"", fontsize=30, alpha=0.0),
    ax.set_ylim(0, 9000)
    ax.set_yticks(range(0, 9000, 1000))
    ax.set_yticklabels(labels=range(0, 9000, 1000), rotation=0,
                       minor=False, fontsize=28)
    ax.set_xticklabels(labels=['2012', '2013', '2014'], rotation=0,
                       minor=False, fontsize=28)
    handles, labels = ax.get_legend_handles_labels()
    ax.legend(['Market A', 'Market B',
               'Market C', 'Market D'],
              loc='upper right', fontsize=28)
    ax_position += 1

# look "three subplots"
#plt.tight_layout(pad=0.0, w_pad=-8.0, h_pad=0.0)

# look "one plot"
plt.tight_layout(pad=0., w_pad=-16.5, h_pad=0.0)
axes[1].set_ylabel("")
axes[2].set_ylabel("")
axes[1].set_yticklabels("")
axes[2].set_yticklabels("")
axes[0].legend().set_visible(False)
axes[1].legend().set_visible(False)
axes[2].legend(['Market A', 'Market B',
                'Market C', 'Market D'],
               loc='upper right', fontsize=28)

Die Dataframe-Struktur von "Subset" vor der Gruppierung sieht folgendermaßen aus:

<class 'pandas.core.frame.DataFrame'>
MultiIndex: 105216 entries, (D_REC, 2012-01-01 00:00:00) to (D_REC, 2014-12-31 23:45:00)
Data columns (total 4 columns):
cmp_tr_neg_p_wrk    105216 non-null float64
exp_tr_pos_p_wrk    105216 non-null float64
cmp_p_spot          105216 non-null float64
exp_p_spot          105216 non-null float64
dtypes: float64(4)
memory usage: 4.0+ MB

und die Handlung wie folgt:

Es ist im "ggplot" -Stil mit der folgenden Kopfzeile formatiert:

import pandas as pd
import matplotlib.pyplot as plt
import matplotlib
matplotlib.style.use('ggplot')

Dies ist ein großartiger Anfang, aber ich denke, die Farben könnten aus Gründen der Klarheit etwas geändert werden. Achten Sie auch darauf, dass Sie jedes Argument in Altair importieren, da dies zu Kollisionen mit vorhandenen Objekten in Ihrem Namespace führen kann. Hier einige rekonfigurierte Codes, um beim Stapeln der Werte die korrekte Farbanzeige anzuzeigen:

Pakete importieren

import pandas as pd
import numpy as np
import altair as alt

Erzeugen Sie einige zufällige Daten

df1=pd.DataFrame(10*np.random.Rand(4,3),index=["A","B","C","D"],columns=["I","J","K"])
df2=pd.DataFrame(10*np.random.Rand(4,3),index=["A","B","C","D"],columns=["I","J","K"])
df3=pd.DataFrame(10*np.random.Rand(4,3),index=["A","B","C","D"],columns=["I","J","K"])

def prep_df(df, name):
    df = df.stack().reset_index()
    df.columns = ['c1', 'c2', 'values']
    df['DF'] = name
    return df

df1 = prep_df(df1, 'DF1')
df2 = prep_df(df2, 'DF2')
df3 = prep_df(df3, 'DF3')

df = pd.concat([df1, df2, df3])

Zeichnen Sie Daten mit Altair auf

alt.Chart(df).mark_bar().encode(

    # tell Altair which field to group columns on
    x=alt.X('c2:N',
        axis=alt.Axis(
            title='')),

    # tell Altair which field to use as Y values and how to calculate
    y=alt.Y('sum(values):Q',
        axis=alt.Axis(
            grid=False,
            title='')),

    # tell Altair which field to use to use as the set of columns to be  represented in each group
    column=alt.Column('c1:N',
                 axis=alt.Axis(
            title='')),

    # tell Altair which field to use for color segmentation 
    color=alt.Color('DF:N',
            scale=alt.Scale(
                # make it look pretty with an enjoyable color pallet
                range=['#96ceb4', '#ffcc5c','#ff6f69'],
            ),
        ))\
    .configure_facet_cell(
    # remove grid lines around column clusters
        strokeWidth=0.0)

Die Antwort von @jrjc für die Verwendung von seaborn ist sehr klug, hat jedoch einige Probleme, wie vom Autor festgestellt:

1. Die "leichte" Schattierung ist zu blass, wenn nur zwei oder drei Kategorien benötigt werden. Farbreihen (hellblau, blau, dunkelblau usw.) lassen sich nur schwer unterscheiden.
2. Die Legende wird nicht erstellt, um die Bedeutung der Schattierungen zu unterscheiden ("blass" bedeutet was?)

Wichtiger, ich fand jedoch heraus, dass aufgrund der groupby-Anweisung im Code:

3. Diese Lösung funktioniert nur, wenn die Spalten alphabetisch angeordnet sind. Wenn ich Spalten ["I", "J", "K", "L", "M"] durch etwas Anti-Alphabetisches (["zI", "yJ", "xK", "wL", "vM"]) umbenenne, ich bekomme stattdessen diese Grafik :

Ich bemühte mich, diese Probleme mit der Funktion plot_grouped_stackedbars() in diesem Open-Source-Python-Modul zu lösen.

1. Es hält die Schattierung in einem vernünftigen Bereich
2. Es generiert automatisch eine Legende, die die Schattierung erklärt
3. Es ist nicht abhängig von groupby

Es erlaubt auch

1. verschiedene Normalisierungsoptionen (siehe unten Normalisierung auf 100% des Maximalwertes)
2. das Hinzufügen von Fehlerbalken

Siehe vollständige Demo hier . Ich hoffe, dass sich dies als nützlich erweist und die ursprüngliche Frage beantworten kann.

Du bist auf dem richtigen Weg! Um die Reihenfolge der Balken zu ändern, sollten Sie die Reihenfolge im Index ändern. 

In [5]: df_both = pd.concat(dict(df1 = df1, df2 = df2),axis = 0)

In [6]: df_both
Out[6]:
              I         J
df1 A  0.423816  0.094405
    B  0.825094  0.759266
    C  0.654216  0.250606
    D  0.676110  0.495251
df2 A  0.607304  0.336233
    B  0.581771  0.436421
    C  0.233125  0.360291
    D  0.519266  0.199637

[8 rows x 2 columns]

Also wollen wir die Achsen tauschen und neu ordnen. Hier ist ein einfacher Weg, dies zu tun

In [7]: df_both.swaplevel(0,1)
Out[7]:
              I         J
A df1  0.423816  0.094405
B df1  0.825094  0.759266
C df1  0.654216  0.250606
D df1  0.676110  0.495251
A df2  0.607304  0.336233
B df2  0.581771  0.436421
C df2  0.233125  0.360291
D df2  0.519266  0.199637

[8 rows x 2 columns]

In [8]: df_both.swaplevel(0,1).sort_index()
Out[8]:
              I         J
A df1  0.423816  0.094405
  df2  0.607304  0.336233
B df1  0.825094  0.759266
  df2  0.581771  0.436421
C df1  0.654216  0.250606
  df2  0.233125  0.360291
D df1  0.676110  0.495251
  df2  0.519266  0.199637

[8 rows x 2 columns]

Wenn es wichtig ist, dass Ihre horizontalen Beschriftungen in der alten Reihenfolge (df1, A) anstatt (A, df1) angezeigt werden, können wir einfach wieder swaplevels und nicht sort_index:

In [9]: df_both.swaplevel(0,1).sort_index().swaplevel(0,1)
Out[9]:
              I         J
df1 A  0.423816  0.094405
df2 A  0.607304  0.336233
df1 B  0.825094  0.759266
df2 B  0.581771  0.436421
df1 C  0.654216  0.250606
df2 C  0.233125  0.360291
df1 D  0.676110  0.495251
df2 D  0.519266  0.199637

[8 rows x 2 columns]

Ich mochte die Lösung von Cord Kaldemeyer, aber sie ist überhaupt nicht robust (und enthält einige nutzlose Zeilen). Hier ist eine modifizierte Version. Die Idee ist, so viel Breite wie nötig für die Grundstücke zu reservieren. Dann erhält jeder Cluster eine Unterzeichnung mit der erforderlichen Länge.

# Data and imports

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.ticker import MaxNLocator
import matplotlib.gridspec as gridspec
import matplotlib

matplotlib.style.use('ggplot')

np.random.seed(0)

df = pd.DataFrame(np.asarray(1+5*np.random.random((10,4)), dtype=int),columns=["Cluster", "Bar", "Bar_part", "Count"])
df = df.groupby(["Cluster", "Bar", "Bar_part"])["Count"].sum().unstack(fill_value=0)
display(df)

# plotting

clusters = df.index.levels[0]
inter_graph = 0
maxi = np.max(np.sum(df, axis=1))
total_width = len(df)+inter_graph*(len(clusters)-1)

fig = plt.figure(figsize=(total_width,10))
gridspec.GridSpec(1, total_width)
axes=[]

ax_position = 0
for cluster in clusters:
    subset = df.loc[cluster]
    ax = subset.plot(kind="bar", stacked=True, width=0.8, ax=plt.subplot2grid((1,total_width), (0,ax_position), colspan=len(subset.index)))
    axes.append(ax)
    ax.set_title(cluster)
    ax.set_xlabel("")
    ax.set_ylim(0,maxi+1)
    ax.yaxis.set_major_locator(MaxNLocator(integer=True))
    ax_position += len(subset.index)+inter_graph

for i in range(1,len(clusters)):
    axes[i].set_yticklabels("")
    axes[i-1].legend().set_visible(False)
axes[0].set_ylabel("y_label")

fig.suptitle('Big Title', fontsize="x-large")
legend = axes[-1].legend(loc='upper right', fontsize=16, framealpha=1).get_frame()
legend.set_linewidth(3)
legend.set_edgecolor("black")

plt.show()

Das Ergebnis ist das Folgende:

(kann noch kein Bild direkt auf der Seite posten)

Altair kann hier hilfreich sein. Hier ist die produzierte Handlung.

Importe

import pandas as pd
import numpy as np
from altair import *

Erstellung von Datensätzen

df1=pd.DataFrame(10*np.random.Rand(4,2),index=["A","B","C","D"],columns=["I","J"])
df2=pd.DataFrame(10*np.random.Rand(4,2),index=["A","B","C","D"],columns=["I","J"])

Datensatz vorbereiten

def prep_df(df, name):
    df = df.stack().reset_index()
    df.columns = ['c1', 'c2', 'values']
    df['DF'] = name
    return df

df1 = prep_df(df1, 'DF1')
df2 = prep_df(df2, 'DF2')

df = pd.concat([df1, df2])

Altair-Plot

Chart(df).mark_bar().encode(y=Y('values', axis=Axis(grid=False)),
                            x='c2:N', 
                            column=Column('c1:N') ,
                            color='DF:N').configure_facet_cell( strokeWidth=0.0).configure_cell(width=200, height=200)