Zeichnen Sie mit matplotlib verschiedene Farben für verschiedene kategoriale Ebenen

Ich habe diesen Datenrahmen, diamondsder sich aus Variablen wie zusammensetzt (carat, price, color), und ich möchte für jeden ein Streudiagramm von pricebis zeichnen , was bedeutet, dass verschiedene unterschiedliche Farben im Diagramm haben.caratcolorcolor

Dies ist leicht in Rmit ggplot:

ggplot(aes(x=carat, y=price, color=color),  #by setting color=color, ggplot automatically draw in different colors
       data=diamonds) + geom_point(stat='summary', fun.y=median)

Ich frage mich, wie das in Python mit gemacht werden könnte matplotlib.

PS:

Ich kenne mich mit zusätzlichen Plot- Paketen wie seabornund aus ggplot for python, und ich bevorzuge sie nicht. Ich möchte nur herausfinden, ob es möglich ist, die Arbeit matplotliballeine zu erledigen

Sie können plt.scatterein cArgument übergeben, mit dem Sie die Farben auswählen können. Der folgende Code definiert ein colorsWörterbuch, um Ihre Diamantfarben den Plotfarben zuzuordnen.

import matplotlib.pyplot as plt
import pandas as pd

carat = [5, 10, 20, 30, 5, 10, 20, 30, 5, 10, 20, 30]
price = [100, 100, 200, 200, 300, 300, 400, 400, 500, 500, 600, 600]
color =['D', 'D', 'D', 'E', 'E', 'E', 'F', 'F', 'F', 'G', 'G', 'G',]

df = pd.DataFrame(dict(carat=carat, price=price, color=color))

fig, ax = plt.subplots()

colors = {'D':'red', 'E':'blue', 'F':'green', 'G':'black'}

ax.scatter(df['carat'], df['price'], c=df['color'].apply(lambda x: colors[x]))

plt.show()

df['color'].apply(lambda x: colors[x]) Ordnet die Farben effektiv von "Diamant" bis "Plotten" zu.

(Verzeihen Sie mir, dass ich kein weiteres Beispielbild erstellt habe. Ich denke, 2 ist genug: P)

Mit seaborn

Sie können seaborneinen Wrapper verwenden matplotlib, der es standardmäßig hübscher aussehen lässt (eher meinungsbasiert, ich weiß: P), aber auch einige Plotfunktionen hinzufügt.

Hierfür können Sie seaborn.lmplotmit verwenden fit_reg=False(was verhindert, dass automatisch eine Regression durchgeführt wird).

Der folgende Code verwendet einen Beispieldatensatz. Durch Auswahl dieser hue='color'Option weisen Sie seaborn an, Ihren Datenrahmen anhand Ihrer Farben aufzuteilen und dann jeden einzelnen zu zeichnen.

import matplotlib.pyplot as plt
import seaborn as sns

import pandas as pd

carat = [5, 10, 20, 30, 5, 10, 20, 30, 5, 10, 20, 30]
price = [100, 100, 200, 200, 300, 300, 400, 400, 500, 500, 600, 600]
color =['D', 'D', 'D', 'E', 'E', 'E', 'F', 'F', 'F', 'G', 'G', 'G',]

df = pd.DataFrame(dict(carat=carat, price=price, color=color))

sns.lmplot('carat', 'price', data=df, hue='color', fit_reg=False)

plt.show()

Ohne zu seabornbenutzenpandas.groupby

Wenn Sie Seaborn nicht verwenden möchten, können Sie pandas.groupbydie Farben allein verwenden und sie dann nur mit matplotlib zeichnen. Sie müssen jedoch die Farben manuell zuweisen. Ich habe unten ein Beispiel hinzugefügt:

fig, ax = plt.subplots()

colors = {'D':'red', 'E':'blue', 'F':'green', 'G':'black'}

grouped = df.groupby('color')
for key, group in grouped:
    group.plot(ax=ax, kind='scatter', x='carat', y='price', label=key, color=colors[key])

plt.show()

Dieser Code nimmt denselben DataFrame wie oben an und gruppiert ihn dann basierend auf color. Anschließend werden diese Gruppen durchlaufen und für jede Gruppe geplottet. Um eine Farbe auszuwählen, habe ich ein colorsWörterbuch erstellt, das die Diamantfarbe (zum Beispiel D) einer echten Farbe (zum Beispiel red) zuordnen kann .

Hier ist eine prägnante und generische Lösung für die Verwendung einer Farbpalette für Meeresbewohner.

Zuerst finden Sie eine Farbpalette Sie mögen und es optional visualisieren:

sns.palplot(sns.color_palette("Set2", 8))

Dann können Sie es matplotlibdamit verwenden:

# Unique category labels: 'D', 'F', 'G', ...
color_labels = df['color'].unique()

# List of RGB triplets
rgb_values = sns.color_palette("Set2", 8)

# Map label to RGB
color_map = dict(zip(color_labels, rgb_values))

# Finally use the mapped values
plt.scatter(df['carat'], df['price'], c=df['color'].map(color_map))

Mit Altair .

from altair import *
import pandas as pd

df = datasets.load_dataset('iris')
Chart(df).mark_point().encode(x='petalLength',y='sepalLength', color='species')

Ich hatte die gleiche Frage und habe den ganzen Tag damit verbracht, verschiedene Pakete auszuprobieren.

Ich hatte ursprünglich matlibplot verwendet: und war nicht zufrieden mit der Zuordnung von Kategorien zu vordefinierten Farben; oder Gruppieren / Aggregieren, dann Iterieren durch die Gruppen (und immer noch Farben zuordnen müssen). Ich hatte nur das Gefühl, dass es eine schlechte Paketimplementierung war.

Seaborn würde bei meinem Fall nicht funktionieren, und Altair funktioniert NUR in einem Jupyter-Notizbuch.

Die beste Lösung für mich war PlotNine, das "eine Implementierung einer Grammatik von Grafiken in Python ist und auf ggplot2 basiert".

Unten finden Sie den Plotnine-Code zum Replizieren Ihres R-Beispiels in Python:

from plotnine import *
from plotnine.data import diamonds

g = ggplot(diamonds, aes(x='carat', y='price', color='color')) + geom_point(stat='summary')
print(g)

So sauber und einfach :)

Hier eine Kombination von Markern und Farben aus einer qualitativen Farbkarte in matplotlib:

import itertools
import numpy as np
from matplotlib import markers
import matplotlib.pyplot as plt

m_styles = markers.MarkerStyle.markers
N = 60
colormap = plt.cm.Dark2.colors  # Qualitative colormap
for i, (marker, color) in zip(range(N), itertools.product(m_styles, colormap)):
    plt.scatter(*np.random.random(2), color=color, marker=marker, label=i)
plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0., ncol=4);

Mit df.plot ()

Normalerweise verwende ich beim schnellen Plotten eines DataFrame pd.DataFrame.plot(). Dies nimmt den Index als x-Wert, den Wert als y-Wert und zeichnet jede Spalte separat mit einer anderen Farbe. Ein DataFrame in dieser Form kann mit set_indexund erreicht werden unstack.

import matplotlib.pyplot as plt
import pandas as pd

carat = [5, 10, 20, 30, 5, 10, 20, 30, 5, 10, 20, 30]
price = [100, 100, 200, 200, 300, 300, 400, 400, 500, 500, 600, 600]
color =['D', 'D', 'D', 'E', 'E', 'E', 'F', 'F', 'F', 'G', 'G', 'G',]

df = pd.DataFrame(dict(carat=carat, price=price, color=color))

df.set_index(['color', 'carat']).unstack('color')['price'].plot(style='o')
plt.ylabel('price')

Bei dieser Methode müssen Sie die Farben nicht manuell angeben.

Dieses Verfahren kann für andere Datenreihen sinnvoller sein. In meinem Fall habe ich Zeitreihendaten, daher besteht der MultiIndex aus Datum / Uhrzeit und Kategorien. Es ist auch möglich, diesen Ansatz für mehr als eine Spalte zum Färben zu verwenden, aber die Legende wird durcheinander gebracht.

Normalerweise mache ich das mit Seaborn, das auf Matplotlib aufgebaut ist

import seaborn as sns
iris = sns.load_dataset('iris')
sns.scatterplot(x='sepal_length', y='sepal_width',
              hue='species', data=iris);