trazar diferentes colores para diferentes niveles categóricos usando matplotlib

Tengo este marco de datos diamondsque se compone de variables como (carat, price, color), y quiero dibujar un diagrama de dispersión de pricea caratpara cada una color, lo que significa que diferente colortiene un color diferente en el diagrama.

Esto es fácil 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)

Me pregunto cómo se podría hacer esto en Python usando matplotlib.

PD:

Sé acerca de los paquetes de trazado auxiliares, como seaborny ggplot for python, y no los prefiero, solo quiero saber si es posible hacer el trabajo usando matplotlibsolo,; P

Puede pasar plt.scatterun cargumento que le permitirá seleccionar los colores. El siguiente código define un colorsdiccionario para asignar los colores de su diamante a los colores de trazado.

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]) mapea eficazmente los colores de "diamante" a "trazado".

(Perdóname por no poner otra imagen de ejemplo, creo que 2 es suficiente: P)

Con seaborn

Puede usar seaborncuál es un envoltorio matplotlibque lo hace lucir más bonito por defecto (más bien basado en opiniones, lo sé: P) pero también agrega algunas funciones de trazado.

Para esto, puede usar seaborn.lmplotcon fit_reg=False(lo que evita que automáticamente haga alguna regresión).

El siguiente código utiliza un conjunto de datos de ejemplo. Al seleccionar, hue='color'le dice a seaborn que divida su marco de datos en función de sus colores y luego trace cada uno.

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

Sin seabornusarpandas.groupby

Si no desea usar seaborn, puede usar pandas.groupbypara obtener los colores solo y luego trazarlos usando solo matplotlib, pero tendrá que asignar colores manualmente a medida que avanza, agregué un ejemplo a continuación:

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

Este código asume el mismo DataFrame que el anterior y luego lo agrupa en función de color. Luego itera sobre estos grupos, trazando para cada uno. Para seleccionar un color, he creado un colorsdiccionario que puede asignar el color del diamante (por ejemplo D) a un color real (por ejemplo red).

Aquí hay una solución sucinta y genérica para usar una paleta de colores marina.

Primero busque una paleta de colores que le guste y, opcionalmente, visualícela:

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

Entonces puedes usarlo para matplotlibhacer esto:

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

Tenía la misma pregunta y me he pasado todo el día probando diferentes paquetes.

Originalmente había usado matlibplot: y no estaba contento con la asignación de categorías a colores predefinidos; o agrupando / agregando luego iterando a través de los grupos (y aún teniendo que mapear colores). Simplemente sentí que era una implementación deficiente del paquete.

Seaborn no funcionaría en mi caso, y Altair SOLO funciona dentro de un Jupyter Notebook.

La mejor solución para mí fue PlotNine, que "es una implementación de una gramática de gráficos en Python y está basada en ggplot2".

A continuación se muestra el código plotnine para replicar su ejemplo de R en 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)

Tan limpio y simple :)

Usando Altair .

from altair import *
import pandas as pd

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

Aquí una combinación de marcadores y colores de un mapa de colores cualitativo en 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, cuando trazo rápidamente un DataFrame, uso pd.DataFrame.plot(). Esto toma el índice como el valor x, el valor como el valor y y traza cada columna por separado con un color diferente. Un DataFrame en esta forma se puede lograr usando set_indexy 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 este método no es necesario especificar los colores manualmente.

Este procedimiento puede tener más sentido para otras series de datos. En mi caso, tengo datos de series de tiempo, por lo que MultiIndex consta de fecha y hora y categorías. También es posible utilizar este enfoque para colorear más de una columna, pero la leyenda se está complicando.

Normalmente lo hago usando Seaborn, que está construido sobre matplotlib

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