Matplotlib Gráfico de Dispersión: Guía Completa de plt.scatter()

Q: ¿Cómo creo un gráfico de dispersión en Matplotlib?

Use plt.scatter(x, y) donde x e y son arrays de la misma longitud. Agregue plt.xlabel(), plt.ylabel() y plt.title() para etiquetas. Llame a plt.show() para mostrar.

Q: ¿Cómo coloreo los puntos del gráfico de dispersión por categoría?

Itere sobre categorías y llame a plt.scatter() para cada una con un color y etiqueta diferentes, luego llame a plt.legend(). Alternativamente, pase un array numérico a c con un mapa de colores.

Q: ¿Cómo agrego una línea de tendencia a un gráfico de dispersión?

Use np.polyfit(x, y, grado) para ajustar un polinomio, cree np.poly1d() a partir de los coeficientes y grafique con plt.plot().

Q: ¿Cuál es la diferencia entre plt.scatter() y plt.plot()?

plt.scatter() crea marcadores individuales con control por punto sobre tamaño, color y forma. plt.plot() crea puntos conectados con apariencia uniforme.

Q: ¿Cómo manejo los puntos superpuestos en un gráfico de dispersión?

Use transparencia alpha, reduzca el tamaño del marcador, use plt.hexbin() para mapas de calor de densidad, o desplace puntos con pequeños offsets aleatorios.

Name: Soren Atelier

Updated on 10/2/2026

Los gráficos de dispersión son la visualización preferida para explorar relaciones entre dos variables numéricas. Pero crear gráficos de dispersión efectivos -- que revelen patrones, clusters y valores atípicos sin convertirse en un desorden -- requiere más que una simple llamada a plt.scatter(). Necesita mapeo de colores para categorías, codificación de tamaño para una tercera variable, etiquetas de ejes apropiadas y manejo de puntos superpuestos.

El plt.scatter() de Matplotlib maneja todo esto con un rico conjunto de parámetros. Esta guía cubre todo, desde gráficos de dispersión básicos hasta técnicas avanzadas como gráficos de burbujas, líneas de regresión y matrices de dispersión multipanel.

📚

Gráfico de Dispersión Básico

import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
x = np.random.randn(100)
y = 2 * x + np.random.randn(100) * 0.5
 
plt.figure(figsize=(8, 6))
plt.scatter(x, y)
plt.xlabel('Valores X')
plt.ylabel('Valores Y')
plt.title('Gráfico de Dispersión Básico')
plt.show()

Personalización de Marcadores

import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
x = np.random.randn(50)
y = np.random.randn(50)
 
plt.figure(figsize=(8, 6))
plt.scatter(x, y,
    s=100,              # tamaño del marcador
    c='steelblue',      # color
    marker='o',         # forma del marcador
    alpha=0.7,          # transparencia
    edgecolors='black', # color del borde
    linewidths=0.5,     # ancho del borde
)
plt.xlabel('X')
plt.ylabel('Y')
plt.title('Gráfico de Dispersión Personalizado')
plt.show()

Formas de Marcador Comunes

Marcador	Símbolo	Descripción
`'o'`	Círculo	Predeterminado
`'s'`	Cuadrado
`'^'`	Triángulo arriba
`'D'`	Diamante
`'*'`	Estrella
`'+'`	Más
`'x'`	Cruz
`'.'`	Punto	Pequeño, para datos densos

Color por Categoría

import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
n = 50
 
# Tres categorías
categories = ['A', 'B', 'C']
colors = ['#e74c3c', '#3498db', '#2ecc71']
 
plt.figure(figsize=(8, 6))
for cat, color in zip(categories, colors):
    x = np.random.randn(n) + (categories.index(cat) * 2)
    y = np.random.randn(n) + (categories.index(cat) * 1.5)
    plt.scatter(x, y, c=color, label=cat, alpha=0.7, s=60, edgecolors='white')
 
plt.xlabel('Característica 1')
plt.ylabel('Característica 2')
plt.title('Gráfico de Dispersión Coloreado por Categoría')
plt.legend()
plt.show()

Mapeo de Color (Variable Continua)

Use el parámetro c con un array numérico y un mapa de colores para codificar una tercera variable como color:

import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
x = np.random.randn(200)
y = np.random.randn(200)
values = x ** 2 + y ** 2  # Distancia desde el origen
 
plt.figure(figsize=(8, 6))
scatter = plt.scatter(x, y, c=values, cmap='viridis', s=50, alpha=0.8)
plt.colorbar(scatter, label='Distancia desde el Origen')
plt.xlabel('X')
plt.ylabel('Y')
plt.title('Gráfico de Dispersión con Mapeo de Color')
plt.show()

Mapas de Colores Populares

Mapa de Color	Tipo	Mejor Para
`'viridis'`	Secuencial	Predeterminado, perceptualmente uniforme
`'plasma'`	Secuencial	Alto contraste
`'coolwarm'`	Divergente	Valores positivos/negativos
`'RdYlGn'`	Divergente	Rangos bueno/malo
`'Set1'`	Cualitativo	Datos categóricos

Codificación de Tamaño (Gráfico de Burbujas)

Codifique una tercera variable como tamaño de marcador para crear un gráfico de burbujas:

import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
countries = ['US', 'China', 'India', 'Germany', 'Japan', 'UK', 'Brazil', 'France']
gdp = np.array([21.43, 14.34, 2.87, 3.86, 5.08, 2.83, 1.87, 2.72])
population = np.array([331, 1402, 1380, 83, 126, 67, 213, 67])
growth = np.array([2.3, 5.8, 6.5, 1.1, 0.8, 1.4, 1.2, 1.5])
 
plt.figure(figsize=(10, 7))
scatter = plt.scatter(gdp, growth,
    s=population * 2,   # Escalar población para tamaños visibles
    c=range(len(countries)),
    cmap='tab10',
    alpha=0.6,
    edgecolors='black',
)
 
for i, country in enumerate(countries):
    plt.annotate(country, (gdp[i], growth[i]),
        textcoords="offset points", xytext=(10, 5), fontsize=9)
 
plt.xlabel('PIB (Billones USD)')
plt.ylabel('Tasa de Crecimiento del PIB (%)')
plt.title('PIB vs Tasa de Crecimiento (tamaño de burbuja = población)')
plt.show()

Agregar una Línea de Regresión

import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
x = np.random.randn(100) * 3
y = 1.5 * x + np.random.randn(100) * 2
 
# Ajustar regresión lineal
coefficients = np.polyfit(x, y, 1)
poly = np.poly1d(coefficients)
x_line = np.linspace(x.min(), x.max(), 100)
 
plt.figure(figsize=(8, 6))
plt.scatter(x, y, alpha=0.6, s=40, label='Datos')
plt.plot(x_line, poly(x_line), 'r-', linewidth=2,
    label=f'y = {coefficients[0]:.2f}x + {coefficients[1]:.2f}')
 
plt.xlabel('X')
plt.ylabel('Y')
plt.title('Gráfico de Dispersión con Línea de Regresión')
plt.legend()
plt.show()

Manejo de Puntos Superpuestos

Cuando los puntos se superponen mucho, use transparencia, marcadores más pequeños o técnicas basadas en densidad:

import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
x = np.random.randn(5000)
y = np.random.randn(5000)
 
fig, axes = plt.subplots(1, 3, figsize=(15, 5))
 
# Método 1: Transparencia
axes[0].scatter(x, y, alpha=0.1, s=10)
axes[0].set_title('Transparencia Alpha')
 
# Método 2: Marcadores pequeños
axes[1].scatter(x, y, s=1, c='black')
axes[1].set_title('Marcadores Pequeños')
 
# Método 3: Histograma 2D (hexbin)
axes[2].hexbin(x, y, gridsize=30, cmap='YlOrRd')
axes[2].set_title('Densidad Hexbin')
 
plt.tight_layout()
plt.show()

Múltiples Subgráficos

import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
n = 100
 
fig, axes = plt.subplots(2, 2, figsize=(10, 10))
 
# Gráfico 1: Lineal
x1 = np.random.randn(n)
axes[0, 0].scatter(x1, 2 * x1 + np.random.randn(n) * 0.5, c='steelblue', s=30)
axes[0, 0].set_title('Relación Lineal')
 
# Gráfico 2: Cuadrático
x2 = np.linspace(-3, 3, n)
axes[0, 1].scatter(x2, x2**2 + np.random.randn(n) * 0.5, c='coral', s=30)
axes[0, 1].set_title('Relación Cuadrática')
 
# Gráfico 3: Clusters
for i, c in enumerate(['red', 'blue', 'green']):
    cx = np.random.randn(30) + i * 3
    cy = np.random.randn(30) + i * 2
    axes[1, 0].scatter(cx, cy, c=c, s=30, alpha=0.7)
axes[1, 0].set_title('Datos Agrupados')
 
# Gráfico 4: Sin correlación
axes[1, 1].scatter(np.random.randn(n), np.random.randn(n), c='purple', s=30, alpha=0.5)
axes[1, 1].set_title('Sin Correlación')
 
plt.tight_layout()
plt.show()

Gráficos de Dispersión Interactivos con PyGWalker

Para el análisis exploratorio de datos, los gráficos de dispersión estáticos son solo el punto de partida. PyGWalker (opens in a new tab) convierte su DataFrame de pandas en una interfaz interactiva estilo Tableau directamente en Jupyter. Puede arrastrar columnas a los ejes, agregar codificaciones de color y tamaño, y filtrar datos -- todo sin escribir código adicional:

import pandas as pd
import pygwalker as pyg
 
df = pd.DataFrame({'x': x, 'y': y, 'category': np.random.choice(['A', 'B', 'C'], len(x))})
walker = pyg.walk(df)

Referencia de Parámetros de plt.scatter()

Parámetro	Tipo	Descripción
`x, y`	tipo array	Posiciones de datos
`s`	escalar o array	Tamaño(s) de marcador en puntos^2
`c`	color o array	Color(es) de marcador. Array para mapa de colores
`marker`	str	Estilo de marcador ('o', 's', '^', etc.)
`cmap`	str o Colormap	Mapa de colores cuando `c` es numérico
`alpha`	float (0-1)	Transparencia
`edgecolors`	color	Color del borde del marcador
`linewidths`	float	Ancho del borde del marcador
`vmin, vmax`	float	Límites del rango del mapa de colores
`label`	str	Etiqueta de la leyenda

FAQ

¿Cómo creo un gráfico de dispersión en Matplotlib?

Use plt.scatter(x, y) donde x e y son arrays de la misma longitud. Agregue plt.xlabel(), plt.ylabel() y plt.title() para etiquetas. Llame a plt.show() para mostrar el gráfico.

¿Cómo coloreo los puntos del gráfico de dispersión por categoría?

Itere sobre las categorías y llame a plt.scatter() para cada una con un parámetro c diferente y un label. Luego llame a plt.legend() para mostrar la leyenda. Alternativamente, pase un array numérico a c con un mapa de colores para coloreo continuo.

¿Cómo agrego una línea de tendencia a un gráfico de dispersión?

Use np.polyfit(x, y, grado) para ajustar un polinomio, cree un np.poly1d() a partir de los coeficientes y grafíquelo con plt.plot(). Para grado=1, esto da una línea de regresión lineal.

¿Cuál es la diferencia entre plt.scatter() y plt.plot()?

plt.scatter() crea marcadores individuales con control por punto sobre tamaño, color y forma. plt.plot() con un estilo de marcador crea puntos conectados con apariencia uniforme. Use scatter() cuando los puntos necesiten estilo individual; use plot() para gráficos de líneas o marcadores uniformes.

¿Cómo manejo los puntos superpuestos en un gráfico de dispersión?

Use alpha (transparencia) para revelar la densidad, reduzca el tamaño s del marcador, use plt.hexbin() para mapas de calor de densidad, o desplace los puntos ligeramente con pequeños offsets aleatorios.

Conclusión

El plt.scatter() de Matplotlib es la herramienta estándar para crear gráficos de dispersión en Python. Para exploración básica, un simple plt.scatter(x, y) es suficiente. Para figuras de calidad de publicación, aproveche el mapeo de colores para categorías, la codificación de tamaño para una tercera variable, las líneas de regresión para tendencias y la transparencia para datos densos. Domine estas técnicas y podrá visualizar cualquier relación bivariada de manera efectiva.

📚