tracciare colori diversi per diversi livelli categoriali utilizzando matplotlib

Ho questo frame di dati diamondsche è composto da variabili come (carat, price, color), e voglio disegnare un grafico a dispersione di priceper caratper ogni color, il che significa diverso colorha colore diverso nella trama.

Questo è facile Rcon 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)

Mi chiedo come potrebbe essere fatto in Python usando matplotlib?

PS:

Conosco pacchetti di plottaggio ausiliari, come seaborne ggplot for python, e non li preferisco, voglio solo scoprire se è possibile fare il lavoro usando matplotlibda solo,; P

Puoi passare plt.scatterun cargomento che ti permetterà di selezionare i colori. Il seguente codice definisce un colorsdizionario per mappare i colori di diamanti ai colori stampa.

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]) mappa efficacemente i colori dal "diamante" al "disegno".

(Perdonami per non aver inserito un'altra immagine di esempio, penso che 2 sia sufficiente: P)

Con seaborn

Puoi usare seabornche è un wrapper matplotlibche lo rende più carino per impostazione predefinita (piuttosto basato sull'opinione, lo so: P) ma aggiunge anche alcune funzioni di plottaggio.

Per questo potresti usare seaborn.lmplotcon fit_reg=False(che gli impedisce di fare automaticamente qualche regressione).

Il codice seguente utilizza un set di dati di esempio. Selezionando hue='color'si dice a seaborn di suddividere il dataframe in base ai colori e quindi di tracciare ciascuno di essi.

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

Senza seabornusarepandas.groupby

Se non vuoi usare seaborn, puoi usare pandas.groupbyper ottenere i colori da soli e poi stamparli usando solo matplotlib, ma dovrai assegnare manualmente i colori mentre procedi, ho aggiunto un esempio di seguito:

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

Questo codice presuppone lo stesso DataFrame di sopra e quindi lo raggruppa in base a color. Quindi itera su questi gruppi, tracciando per ciascuno di essi. Per selezionare un colore ho creato un colorsdizionario che può mappare il colore del diamante (ad esempio D) a un colore reale (ad esempio red).

Ecco una soluzione succinta e generica per utilizzare una tavolozza di colori marini.

Per prima cosa trova una tavolozza di colori che ti piace e opzionalmente visualizzala:

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

Quindi puoi usarlo matplotlibfacendo questo:

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

Avevo la stessa domanda e ho passato tutto il giorno a provare diversi pacchetti.

Inizialmente avevo usato matlibplot: e non ero soddisfatto di nessuna delle categorie di mappatura a colori predefiniti; o raggruppando / aggregando quindi iterando attraverso i gruppi (e dovendo ancora mappare i colori). Ho solo sentito che era una cattiva implementazione del pacchetto.

Seaborn non funzionerebbe sul mio caso e Altair funziona SOLO all'interno di un taccuino Jupyter.

La soluzione migliore per me era PlotNine, che "è un'implementazione di una grammatica grafica in Python e basata su ggplot2".

Di seguito è riportato il codice di plotnine per replicare il tuo esempio R 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)

Così pulito e semplice :)

Utilizzando Altair .

from altair import *
import pandas as pd

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

Ecco una combinazione di pennarelli e colori da una mappa colori qualitativa 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);

Con df.plot ()

Normalmente quando traccio rapidamente un DataFrame, uso pd.DataFrame.plot(). Questo prende l'indice come valore x, il valore come valore y e traccia ogni colonna separatamente con un colore diverso. Un DataFrame in questa forma può essere ottenuto utilizzando set_indexe 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')

Con questo metodo non è necessario specificare manualmente i colori.

Questa procedura può avere più senso per altre serie di dati. Nel mio caso ho i dati della serie temporale, quindi il MultiIndex è composto da datetime e categorie. È anche possibile utilizzare questo approccio per colorare più di una colonna, ma la legenda sta diventando un pasticcio.

Di solito lo faccio usando Seaborn che è costruito sopra matplotlib

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