📚 Matplotlib Scatter: Ejemplos y Aplicaciones Básicas

Acordeón de los Índices de Matplotlib Scatter

Índice de los temas

• Creating Scatter Plots
• Compare Plots
• Colors
• Color Each Dot
• ColorMap
• Available ColorMaps
• Size
• Alpha
• Combine Color Size and Alpha

---

Lección: 10 - Matplotlib Scatter

Creating Scatter Plots

⚫ Los **gráficos de dispersión** (scatter plots) son una herramienta fundamental para visualizar la relación entre dos conjuntos de datos numéricos. En un gráfico de dispersión, cada punto representa un par de valores (uno para el eje x y otro para el eje y), lo que permite identificar patrones, correlaciones y la distribución de los datos.

En Matplotlib, puedes crear gráficos de dispersión utilizando la función `plt.scatter(x, y)`, donde `x` e `y` son arrays similares a listas que contienen los datos para los ejes horizontal y vertical, respectivamente.

A diferencia de la función `plt.plot()`, que conecta los puntos con líneas, `plt.scatter()` muestra los puntos individualmente.

💻 Código de Ejemplo: Creando un gráfico de dispersión simple

import matplotlib.pyplot as plt
import numpy as np

# Datos de ejemplo
x = np.array([5, 7, 8, 7, 2, 17, 2, 9, 4, 11, 12, 9, 6])
y = np.array([99, 86, 87, 88, 111, 86, 103, 87, 94, 78, 77, 85, 86])

plt.scatter(x, y)
plt.xlabel("Eje X")
plt.ylabel("Eje Y")
plt.title("Gráfico de Dispersión Simple")
plt.show()
            

Este código genera un gráfico de dispersión donde cada punto representa un par de valores tomados de los arrays `x` e `y`. La posición de cada punto en el gráfico indica la magnitud de estos valores.

📊 Ejemplo Visual Interactivo (Generado con JavaScript)

👆 Este gráfico generado con JavaScript muestra la representación visual de un gráfico de dispersión, donde cada punto representa una observación.

Compare Plots

🤝 Una de las ventajas de los gráficos de dispersión es la capacidad de **comparar múltiples conjuntos de datos** en un mismo plano. Esto permite visualizar las relaciones entre diferentes variables o grupos de observaciones de manera simultánea.

Para comparar gráficos de dispersión, simplemente llamas a la función `plt.scatter()` varias veces, proporcionando los diferentes conjuntos de datos para `x` e `y` en cada llamada. Es importante distinguir visualmente cada conjunto de datos utilizando diferentes colores, marcadores o etiquetas en la leyenda.

💻 Código de Ejemplo: Comparando dos gráficos de dispersión

import matplotlib.pyplot as plt
import numpy as np

# Primer conjunto de datos
x1 = np.array([5, 7, 8, 7, 2, 17, 2, 9, 4, 11, 12, 9, 6])
y1 = np.array([99, 86, 87, 88, 111, 86, 103, 87, 94, 78, 77, 85, 86])

# Segundo conjunto de datos
x2 = np.array([2, 2, 8, 1, 15, 8, 12, 9, 7, 3, 11, 4, 7, 14, 12])
y2 = np.array([100, 105, 84, 105, 90, 99, 90, 95, 94, 100, 79, 112, 91, 80, 85])

plt.scatter(x1, y1, color='blue', label='Grupo A')
plt.scatter(x2, y2, color='red', label='Grupo B')

plt.xlabel("Variable X")
plt.ylabel("Variable Y")
plt.title("Comparación de dos grupos de datos")
plt.legend() # Muestra la leyenda para identificar los grupos
plt.show()
            

En este ejemplo, hemos trazado dos conjuntos de datos diferentes en el mismo gráfico de dispersión. Hemos utilizado el argumento `color` para distinguirlos (azul para el Grupo A y rojo para el Grupo B) y hemos añadido una leyenda utilizando `plt.legend()` para identificar cada grupo.

📊 Ejemplo Visual Interactivo (Generado con JavaScript)

👆 Este gráfico generado con JavaScript muestra dos conjuntos de puntos de diferentes colores, lo que permite comparar visualmente sus distribuciones.

Colors

🎨 El **color** de los puntos en un gráfico de dispersión puede ser una herramienta poderosa para distinguir diferentes grupos de datos o para añadir una dimensión visual a la información. Matplotlib ofrece una gran flexibilidad para controlar el color de los puntos.

Puedes especificar el color de todos los puntos en un gráfico de dispersión utilizando el argumento `color` (o su abreviatura `c`) en la función `plt.scatter()`. Este argumento acepta varios tipos de valores, incluyendo:

• Nombres de colores predefinidos (ej: `'red'`, `'green'`, `'blue'`, `'black'`, etc.).
• Códigos de color hexadecimal (ej: `'#FF0000'` para rojo, `'#00FF00'` para verde, `'#0000FF'` para azul).
• Tuplas RGB o RGBA (ej: `(1, 0, 0)` para rojo, `(0, 1, 0, 0.5)` para verde con 50% de transparencia).

💻 Código de Ejemplo: Especificando el color de los puntos

import matplotlib.pyplot as plt
import numpy as np

x = np.array([5, 7, 8, 7, 2, 17, 2, 9, 4, 11, 12, 9, 6])
y = np.array([99, 86, 87, 88, 111, 86, 103, 87, 94, 78, 77, 85, 86])

# Gráfico con todos los puntos en color verde
plt.scatter(x, y, color='green')
plt.xlabel("Eje X")
plt.ylabel("Eje Y")
plt.title("Gráfico de Dispersión con Color Único")
plt.show()

# Gráfico con todos los puntos en color rojo hexadecimal
plt.scatter(x, y, c='#FF0000')
plt.xlabel("Eje X")
plt.ylabel("Eje Y")
plt.title("Gráfico de Dispersión con Color Hexadecimal")
plt.show()
            

En estos ejemplos, hemos creado dos gráficos de dispersión del mismo conjunto de datos, pero hemos especificado un color diferente para todos los puntos en cada gráfico utilizando el argumento `color`.

📊 Ejemplo Visual Interactivo (Generado con JavaScript)

👆 Este gráfico generado con JavaScript muestra un conjunto de puntos con un color uniforme especificado.

Color Each Dot

🌈 Matplotlib te ofrece la posibilidad de asignar un **color diferente a cada punto** en un gráfico de dispersión. Esto es extremadamente útil cuando tienes una tercera dimensión de datos que quieres visualizar a través del color de los puntos.

Para colorear cada punto individualmente, debes pasar un **array de colores** al argumento `color` (o `c`) de la función `plt.scatter()`. La longitud de este array de colores debe ser la misma que la longitud de los arrays de datos `x` e `y`. Cada elemento del array de colores especificará el color del punto correspondiente.

Puedes utilizar nombres de colores, códigos hexadecimales o tuplas RGB(A) dentro de este array de colores.

💻 Código de Ejemplo: Coloreando cada punto individualmente

import matplotlib.pyplot as plt
import numpy as np

x = np.array([5, 7, 8, 7, 2, 17, 2, 9, 4, 11, 12, 9, 6])
y = np.array([99, 86, 87, 88, 111, 86, 103, 87, 94, 78, 77, 85, 86])
colors = np.array(['red', 'green', 'blue', 'yellow', 'pink', 'black', 'orange', 'purple', 'brown', 'lime', 'cyan', 'magenta', 'gray'])

plt.scatter(x, y, color=colors)
plt.xlabel("Eje X")
plt.ylabel("Eje Y")
plt.title("Gráfico de Dispersión con Colores Individuales")
plt.show()
            

En este ejemplo, hemos creado un array llamado `colors` que contiene un color diferente para cada punto de datos. Al pasar este array al argumento `color` de `plt.scatter()`, cada punto se dibuja con el color correspondiente de la lista.

📊 Ejemplo Visual Interactivo (Generado con JavaScript)

👆 Este gráfico generado con JavaScript muestra cómo cada punto puede tener un color distinto, basado en un array de colores.

ColorMap

🌡️ Un **colormap** es una secuencia de colores que se utilizan para representar la variación de una tercera variable en un gráfico de dispersión. En lugar de asignar un color fijo a cada punto, el color de cada punto se determina por su valor correspondiente en una tercera dimensión de datos.

Para utilizar un colormap en Matplotlib, debes hacer lo siguiente:

1. Proporcionar un array de valores para la tercera dimensión al argumento `c` de la función `plt.scatter()`.
2. Especificar el colormap que deseas utilizar con el argumento `cmap`. Matplotlib tiene una amplia variedad de colormaps disponibles (ver el siguiente tema).

Matplotlib normalizará automáticamente los valores de tu tercera dimensión al rango del colormap, asignando colores de la secuencia del colormap a los puntos en función de sus valores.

Es común incluir una **barra de color** (colorbar) para mostrar la correspondencia entre los colores y los valores de la tercera dimensión. Esto se añade utilizando la función `plt.colorbar()`.

💻 Código de Ejemplo: Utilizando un colormap

import matplotlib.pyplot as plt
import numpy as np

x = np.array([5, 7, 8, 7, 2, 17, 2, 9, 4, 11, 12, 9, 6])
y = np.array([99, 86, 87, 88, 111, 86, 103, 87, 94, 78, 77, 85, 86])
colors = np.array([0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120]) # Tercera dimensión de datos

plt.scatter(x, y, c=colors, cmap='viridis') # 'viridis' es un colormap común
plt.colorbar(label='Magnitud') # Añade una barra de color con una etiqueta
plt.xlabel("Eje X")
plt.ylabel("Eje Y")
plt.title("Gráfico de Dispersión con Colormap")
plt.show()
            

En este ejemplo, el array `colors` representa la tercera dimensión de datos. Al pasarlo al argumento `c` y especificar el colormap `'viridis'`, los puntos se colorean según estos valores. La barra de color muestra la escala de colores y su correspondencia con los valores de la magnitud.

📊 Ejemplo Visual Interactivo (Generado con JavaScript)

👆 Este gráfico generado con JavaScript simula el uso de un colormap, donde el color de cada punto varía según una tercera variable, y se incluye una leyenda de color.

Available ColorMaps

🌈 Matplotlib ofrece una **amplia gama de colormaps** que puedes utilizar para visualizar la tercera dimensión de tus datos en gráficos de dispersión. La elección del colormap adecuado puede influir significativamente en cómo se perciben los datos y en la efectividad de la comunicación visual.

Los colormaps en Matplotlib se organizan en varias categorías:

• **Sequential:** Cambios graduales en la luminancia, a menudo con un cambio en el matiz. Adecuados para datos que tienen un orden desde bajo a alto. Ejemplos: `'viridis'`, `'magma'`, `'plasma'`, `'inferno'`, `'cividis'`, `'Greys'`, `'Blues'`, `'Greens'`, `'Reds'`.
• **Diverging:** Dos rangos de variación de luminancia con un color intermedio típicamente claro o neutro. Útiles para datos que tienen un punto medio significativo, como desviaciones de cero. Ejemplos: `'coolwarm'`, `'bwr'`, `'RdBu'`, `'seismic'`.
• **Qualitative:** Cambios rápidos de color sin un orden implícito. Útiles para representar datos categóricos o discretos. Ejemplos: `'tab10'`, `'tab20'`, `'Set1'`, `'Set2'`, `'Accent'`.
• **Miscellaneous:** Colormaps que no encajan claramente en las categorías anteriores. Ejemplos: `'jet'`, `'rainbow'`, `'terrain'`. (Nota: algunos de estos pueden no ser perceptualmente uniformes).

Puedes especificar el nombre del colormap directamente en el argumento `cmap` de la función `plt.scatter()`. Es recomendable elegir colormaps que sean perceptualmente uniformes y amigables para personas con daltonismo, como `'viridis'` o `'cividis'` para datos secuenciales.

💻 Código de Ejemplo: Visualizando algunos colormaps

import matplotlib.pyplot as plt
import numpy as np

# Datos de ejemplo (posición común para visualizar el efecto del colormap)
x = np.linspace(0, 10, 100)
y = np.linspace(0, 10, 100)
z = np.sqrt(x[:, np.newaxis]**2 + y[np.newaxis, :]**2) # Una función para generar una tercera dimensión

colormaps = ['viridis', 'plasma', 'coolwarm', 'jet', 'Greys']

plt.figure(figsize=(12, 8))
for i, cmap_name in enumerate(colormaps):
    plt.subplot(2, 3, i + 1)
    plt.scatter(x, y, c=z, cmap=cmap_name)
    plt.title(cmap_name)
    plt.xticks([])
    plt.yticks([])

plt.tight_layout()
plt.show()
            

Este código genera una figura con cinco subgráficos, cada uno mostrando los mismos datos de dispersión coloreados con un colormap diferente de la lista `colormaps`. Esto permite visualizar cómo diferentes colormaps representan la misma tercera dimensión de datos.

📊 Ejemplo Visual Interactivo (Generado con JavaScript)

👆 Esta área mostrará visualizaciones de algunos colormaps comunes generados con JavaScript.

Size

🔘 El **tamaño** de los puntos en un gráfico de dispersión es otra propiedad visual que puedes ajustar para mejorar la claridad o para representar una cuarta dimensión de datos. Puntos más grandes pueden destacar ciertas observaciones o indicar una mayor magnitud de alguna variable.

Puedes controlar el tamaño de los puntos utilizando el argumento `s` (de "size") en la función `plt.scatter()`. Este argumento acepta:

• Un **valor escalar:** Si proporcionas un único número, todos los puntos tendrán ese mismo tamaño (en puntos al cuadrado).
• Un **array de valores:** Si proporcionas un array de la misma longitud que tus datos `x` e `y`, cada punto tendrá un tamaño diferente correspondiente al valor en el array `s`. Esto te permite mapear una cuarta dimensión de tus datos al tamaño de los puntos.

💻 Código de Ejemplo: Controlando el tamaño de los puntos

import matplotlib.pyplot as plt
import numpy as np

# Datos de ejemplo
x = np.array([5, 7, 8, 7, 2, 17, 2, 9, 4, 11, 12, 9, 6])
y = np.array([99, 86, 87, 88, 111, 86, 103, 87, 94, 78, 77, 85, 86])

# Tamaño único para todos los puntos
plt.figure(figsize=(6, 4))
plt.scatter(x, y, s=100) # Todos los puntos con tamaño 100
plt.title("Tamaño Único")
plt.show()

# Tamaños diferentes para cada punto
sizes = np.array([20, 50, 100, 80, 60, 150, 30, 90, 40, 120, 110, 70, 55])
plt.figure(figsize=(6, 4))
plt.scatter(x, y, s=sizes) # Cada punto con un tamaño diferente
plt.title("Tamaños Variables")
plt.show()

# Combinando color y tamaño
colors = np.array([0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120])
plt.figure(figsize=(6, 4))
plt.scatter(x, y, c=colors, s=sizes, cmap='viridis')
plt.colorbar(label='Magnitud del Color')
plt.title("Color y Tamaño Variables")
plt.show()
            

El primer gráfico muestra todos los puntos con el mismo tamaño. El segundo gráfico muestra cada punto con un tamaño diferente basado en el array `sizes`. El tercer gráfico combina el uso de color (basado en el array `colors` y un colormap) con el tamaño variable.

📊 Ejemplo Visual Interactivo (Generado con JavaScript)

👆 Este gráfico generado con JavaScript ilustra cómo variar el tamaño de los puntos en un gráfico de dispersión.

Alpha

👻 La **transparencia** (o alpha) de los puntos en un gráfico de dispersión controla qué tan opacos o transparentes son los puntos. Ajustar la transparencia puede ser útil en varias situaciones:

• **Manejar la sobreposición:** Cuando tienes muchos puntos que se superponen, reducir la transparencia puede hacer que las áreas con mayor densidad de puntos aparezcan más oscuras, revelando patrones que de otra manera estarían ocultos.
• **Añadir una dimensión visual sutil:** Puedes usar la transparencia para codificar una quinta dimensión de datos, aunque esto debe hacerse con cuidado para no dificultar la lectura del gráfico.

Puedes controlar la transparencia de los puntos utilizando el argumento `alpha` en la función `plt.scatter()`. El valor de `alpha` debe estar entre 0 y 1, donde 0 es completamente transparente y 1 es completamente opaco.

Al igual que con el color y el tamaño, puedes proporcionar un valor escalar para aplicar la misma transparencia a todos los puntos, o un array de valores para aplicar una transparencia diferente a cada punto.

💻 Código de Ejemplo: Controlando la transparencia (alpha)

import matplotlib.pyplot as plt
import numpy as np

# Datos de ejemplo con algunos puntos superpuestos
x = np.random.rand(100)
y = np.random.rand(100)

# Transparencia única para todos los puntos
plt.figure(figsize=(6, 4))
plt.scatter(x, y, alpha=0.5) # Puntos semi-transparentes
plt.title("Transparencia Única (alpha=0.5)")
plt.show()

# Transparencia variable basada en la posición en el array
alpha_values = np.linspace(0.1, 1, 100)
plt.figure(figsize=(6, 4))
plt.scatter(x, y, alpha=alpha_values)
plt.title("Transparencia Variable")
plt.show()

# Combinando color y transparencia
colors = np.random.rand(100)
plt.figure(figsize=(6, 4))
plt.scatter(x, y, c=colors, alpha=0.7, cmap='viridis')
plt.colorbar(label='Valor del Color')
plt.title("Color y Transparencia")
plt.show()
            

El primer gráfico muestra puntos semi-transparentes, lo que ayuda a visualizar las áreas de mayor densidad. El segundo gráfico aplica una transparencia que varía linealmente a lo largo de los puntos. El tercer gráfico combina el color con una transparencia uniforme.

📊 Ejemplo Visual Interactivo (Generado con JavaScript)

👆 Este gráfico generado con JavaScript ilustra cómo ajustar la transparencia de los puntos en un gráfico de dispersión.

Combine Color Size and Alpha

✨ La verdadera potencia de los gráficos de dispersión se revela cuando **combinas múltiples atributos visuales** para representar diferentes dimensiones de tus datos. Al usar simultáneamente el color, el tamaño y la transparencia de los puntos, puedes crear visualizaciones ricas en información que revelan relaciones complejas.

Para combinar estas propiedades, simplemente pasa los arrays correspondientes a los argumentos `c` (o `color`), `s` (o `size`), y `alpha` en la función `plt.scatter()`. Asegúrate de que la longitud de estos arrays coincida con la longitud de tus datos `x` e `y` si deseas que cada punto tenga sus propias características únicas.

Al interpretar gráficos que combinan múltiples atributos, es crucial incluir una **leyenda** para el color (si se usa un colormap) y considerar si el tamaño o la transparencia también necesitan una explicación (por ejemplo, si el tamaño representa una magnitud específica).

💻 Código de Ejemplo: Combinando color, tamaño y transparencia

import matplotlib.pyplot as plt
import numpy as np

# Datos de ejemplo (simulando 5 dimensiones)
np.random.seed(0)
x = np.random.rand(50)
y = np.random.rand(50)
colors = np.random.rand(50)
sizes = (30 * np.random.rand(50))**2 # Tamaños variables
alpha_values = np.linspace(0.3, 0.9, 50) # Transparencia variable

plt.figure(figsize=(8, 6))
scatter = plt.scatter(x, y, c=colors, s=sizes, alpha=alpha_values, cmap='viridis')
plt.colorbar(scatter, label='Valor del Color')
plt.xlabel("Dimensión 1")
plt.ylabel("Dimensión 2")
plt.title("Gráfico de Dispersión Combinando Color, Tamaño y Transparencia")
plt.show()
            

En este ejemplo, hemos utilizado arrays aleatorios para simular cinco dimensiones de datos (x, y, color, tamaño y transparencia). El color está mapeado a un colormap ('viridis'), el tamaño varía según el array `sizes`, y la transparencia varía según `alpha_values`. La barra de color ayuda a interpretar la dimensión representada por el color.

📊 Ejemplo Visual Interactivo (Generado con JavaScript)

👆 Este gráfico generado con JavaScript ilustra cómo combinar color, tamaño y transparencia en un gráfico de dispersión para codificar múltiples dimensiones de datos.

---