# Python para Data Analytics: Matplotlib, Seaborn y visualizacion de datos en entrevistas

> Guia practica para dominar Matplotlib y Seaborn en Python orientada a entrevistas tecnicas de data analytics. Cubre la API orientada a objetos, subplots, graficos KDE, heatmaps de correlacion, estilos profesionales y un ejercicio completo de dashboard.

- Published: 2026-04-22
- Updated: 2026-04-22
- Author: SharpSkill
- Tags: python, matplotlib, seaborn, data-visualization, data-analytics, interview
- Reading time: 9 min

---

Cualquier proceso de seleccion para roles de data analytics reserva al menos una etapa para evaluar la capacidad del candidato de transformar numeros en graficos legibles, bien estructurados y con un nivel de presentacion profesional. No se trata unicamente de dominar funciones de una biblioteca: los equipos de contratacion observan como se eligen los tipos de grafico, como se etiquetan los ejes, como se comunican patrones y anomalias, y si el codigo refleja buenas practicas de ingenieria. Matplotlib y Seaborn son las dos bibliotecas que concentran la mayor parte de los ejercicios practicos de visualizacion en entrevistas tecnicas con Python.

Este articulo recorre cada concepto fundamental de ambas herramientas con ejemplos ejecutables, explicaciones de las decisiones de diseno que marcan la diferencia ante un entrevistador y un ejercicio integrador de dashboard que replica las condiciones de una prueba tecnica real. Cada bloque de codigo puede ejecutarse tal cual en un entorno local o en un notebook compartido.

> **Lo que realmente evaluan los entrevistadores**
>
> Tres criterios definen la evaluacion de un ejercicio de visualizacion: la pertinencia del tipo de grafico respecto a la naturaleza de los datos, la claridad de etiquetas, titulos y formato numerico, y la capacidad del candidato de explicar verbalmente cada decision de diseno. El codigo funcional es necesario, pero la narrativa visual es lo que separa a un candidato solido de uno promedio.

## Preparacion del entorno de trabajo

Un entorno aislado con versiones explicitas de cada dependencia elimina problemas de compatibilidad y garantiza que el codigo se comporte de forma identica en cualquier maquina. Los entrevistadores valoran esta practica porque refleja disciplina de ingenieria de software aplicada al trabajo con datos.

```bash
# setup.sh
python -m venv venv
source venv/bin/activate
pip install matplotlib==3.10.8 seaborn==0.13.2 pandas numpy
```

Despues de instalar las dependencias, resulta recomendable confirmar que las versiones coincidan con las esperadas. En entornos de notebook preconfigurados para entrevistas, este paso previene sorpresas con parametros por defecto que cambian entre versiones.

```python
# verify_install.py
import matplotlib
import seaborn as sns
import pandas as pd

print(f"Matplotlib: {matplotlib.__version__}")
print(f"Seaborn: {sns.__version__}")
print(f"Pandas: {pd.__version__}")
```

Con el entorno verificado, el siguiente paso es comprender la arquitectura interna de Matplotlib y el patron de codigo que los entrevistadores esperan encontrar.

## Matplotlib desde cero: Figure, Axes y la API orientada a objetos

Matplotlib expone dos interfaces para construir graficos. La primera, basada en funciones globales como `plt.plot()` y `plt.bar()`, opera sobre un estado implicito que se vuelve problematico en cuanto la visualizacion incluye mas de un panel. La segunda, la API orientada a objetos (OO), trabaja directamente con los objetos `Figure` (el lienzo completo) y `Axes` (cada area de trazado individual). En el contexto de una entrevista tecnica, la API OO es el estandar. Permite referenciar cada componente del grafico de forma explicita, produce codigo mas legible y evita la ambiguedad sobre cual eje se esta modificando.

El patron fundamental consiste en llamar a `plt.subplots()`, que devuelve una tupla con la figura y los ejes, y realizar todas las operaciones sobre el objeto `Axes` correspondiente.

```python
# bar_chart_oo.py
import matplotlib.pyplot as plt
import numpy as np

# Sample quarterly revenue data
quarters = ["Q1", "Q2", "Q3", "Q4"]
revenue = [42_000, 58_000, 51_000, 67_000]

# Create figure and axes explicitly
fig, ax = plt.subplots(figsize=(8, 5))

# Draw bars with a specific color
ax.bar(quarters, revenue, color="#2563eb", width=0.5)

# Label axes clearly — interviewers check for this
ax.set_xlabel("Quarter")
ax.set_ylabel("Revenue (USD)")
ax.set_title("Quarterly Revenue — 2025")

# Format y-axis with dollar amounts
ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"${x:,.0f}"))

# Remove top and right spines for a cleaner look
ax.spines[["top", "right"]].set_visible(False)

plt.tight_layout()
plt.savefig("quarterly_revenue.png", dpi=150)
plt.show()
```

Varios detalles del codigo anterior merecen atencion. Las etiquetas de los ejes incluyen la unidad de medida (USD), lo cual elimina ambiguedad para quien lee el grafico. El formateador `FuncFormatter` transforma valores numericos crudos en cantidades legibles con simbolo de moneda, un refinamiento que la mayoria de candidatos omiten pero que los entrevistadores notan de inmediato. La eliminacion de los bordes superior y derecho con `ax.spines` sigue las convenciones de publicaciones de datos como The Economist o FiveThirtyEight, donde la limpieza visual no es opcional sino un requisito editorial.

El metodo `tight_layout()` ajusta los margenes automaticamente para que las etiquetas no se recorten al exportar la figura, un problema frecuente cuando se trabaja con dimensiones fijas.

## Subplots: visualizaciones con multiples paneles

Los reportes analiticos rara vez se componen de un unico grafico. La capacidad de combinar varias metricas en una sola figura, con escalas independientes y un titulo que unifique la narrativa, es una habilidad que los entrevistadores evaluan directamente porque refleja el tipo de trabajo que se realiza a diario en equipos de datos.

La funcion `plt.subplots()` acepta parametros de filas y columnas para definir la cuadricula de paneles. Cuando se solicitan dos graficos lado a lado, la sintaxis devuelve una tupla de ejes que se desempaqueta directamente.

```python
# subplots_comparison.py
import matplotlib.pyplot as plt
import numpy as np

months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun"]
users = [1200, 1350, 1500, 1420, 1680, 1820]
revenue = [24_000, 27_000, 30_000, 28_400, 33_600, 36_400]

# Two side-by-side plots sharing the x-axis
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5), sharey=False)

# Left panel: user growth as a line chart
ax1.plot(months, users, marker="o", color="#2563eb", linewidth=2)
ax1.set_title("Monthly Active Users")
ax1.set_ylabel("Users")
ax1.spines[["top", "right"]].set_visible(False)

# Right panel: revenue as a bar chart
ax2.bar(months, revenue, color="#16a34a", width=0.5)
ax2.set_title("Monthly Revenue")
ax2.set_ylabel("Revenue (USD)")
ax2.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"${x:,.0f}"))
ax2.spines[["top", "right"]].set_visible(False)

fig.suptitle("Product Metrics — H1 2025", fontsize=14, fontweight="bold")
plt.tight_layout()
plt.savefig("product_metrics.png", dpi=150)
plt.show()
```

El parametro `sharey=False` mantiene escalas independientes en el eje Y, lo cual resulta correcto cuando las unidades difieren (usuarios versus dolares). Forzar un eje compartido en este caso comprimiria uno de los dos graficos y dificultaria la lectura. El titulo general con `fig.suptitle()` proporciona contexto al conjunto, mientras que cada panel conserva sus propios titulos y etiquetas, creando una jerarquia visual clara.

El uso de marcadores (`marker="o"`) en el grafico de linea permite identificar valores individuales con precision, algo especialmente util cuando la serie tiene pocos puntos de datos.

> **El error mas comun con subplots en entrevistas**
>
> Utilizar la interfaz pyplot (`plt.bar()`, `plt.plot()`) en lugar de la API orientada a objetos cuando se trabaja con subplots genera errores silenciosos: pyplot opera sobre el eje "activo" de forma implicita y resulta facil modificar el panel equivocado sin darse cuenta. La API OO elimina esta ambiguedad al exigir que cada operacion se dirija a un objeto `Axes` especifico. Mencionar esta distincion durante una entrevista demuestra comprension profunda de la arquitectura de Matplotlib.

## Seaborn para graficos estadisticos

Seaborn se construye sobre Matplotlib y esta optimizada para la exploracion estadistica de datos estructurados en DataFrames de Pandas. Su ventaja principal radica en la integracion automatica con columnas del DataFrame: basta con indicar los nombres de las variables para que la biblioteca segmente, coloree y calcule estadisticos sin codigo adicional.

Uno de los graficos mas solicitados en entrevistas de data analytics es la comparacion de distribuciones entre grupos. El grafico KDE (Kernel Density Estimation) ofrece una curva suavizada que resulta mas interpretable que un histograma cuando se superponen dos o mas categorias, ya que no depende de la eleccion arbitraria de bins.

```python
# distribution_analysis.py
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

# Simulate salary data for two departments
np.random.seed(42)
data = pd.DataFrame({
    "salary": np.concatenate([
        np.random.normal(75_000, 12_000, 200),  # Engineering
        np.random.normal(65_000, 10_000, 150),  # Marketing
    ]),
    "department": ["Engineering"] * 200 + ["Marketing"] * 150
})

# KDE plot comparing salary distributions
fig, ax = plt.subplots(figsize=(10, 5))
sns.kdeplot(
    data=data,
    x="salary",
    hue="department",        # Automatically splits by category
    fill=True,               # Shaded area under the curve
    alpha=0.4,
    palette=["#2563eb", "#dc2626"],
    ax=ax                    # Attach to our explicit axes
)

ax.set_title("Salary Distribution by Department")
ax.set_xlabel("Annual Salary (USD)")
ax.xaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"${x:,.0f}"))
ax.spines[["top", "right"]].set_visible(False)

plt.tight_layout()
plt.savefig("salary_distribution.png", dpi=150)
plt.show()
```

El parametro `hue="department"` divide automaticamente los datos por departamento y asigna un color diferente a cada grupo. Al combinar `fill=True` con `alpha=0.4`, las areas sombreadas se superponen de forma transparente, lo que permite comparar las distribuciones sin que una oculte a la otra. Este patron es recurrente en entrevistas porque demuestra la capacidad de analizar diferencias entre segmentos de forma visual e inmediata.

Un aspecto que conviene destacar es el parametro `ax=ax`, que conecta el grafico de Seaborn con la API OO de Matplotlib. Esta integracion permite personalizar el resultado mas alla de los valores por defecto de Seaborn -- agregar formateadores, modificar bordes, ajustar titulos -- sin perder las ventajas de la interfaz de alto nivel.

## Heatmaps de correlacion

Las matrices de correlacion son una herramienta central del analisis exploratorio de datos. En entrevistas tecnicas, aparecen con frecuencia porque permiten evaluar simultaneamente la capacidad del candidato de generar el grafico, interpretar los valores y explicar las implicaciones para el negocio. `sns.heatmap()` convierte una matriz de correlacion de Pandas en una representacion visual donde el color de cada celda indica la intensidad y direccion de la relacion lineal entre variables.

```python
# correlation_heatmap.py
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

# Simulate e-commerce metrics
np.random.seed(42)
n = 500
page_views = np.random.poisson(15, n)
time_on_site = page_views * 2.5 + np.random.normal(0, 5, n)
cart_adds = np.random.binomial(page_views, 0.3)
purchases = np.random.binomial(cart_adds, 0.4)

df = pd.DataFrame({
    "page_views": page_views,
    "time_on_site": time_on_site,
    "cart_adds": cart_adds,
    "purchases": purchases
})

# Compute Pearson correlation
corr_matrix = df.corr()

fig, ax = plt.subplots(figsize=(8, 6))
sns.heatmap(
    corr_matrix,
    annot=True,              # Show correlation values in cells
    fmt=".2f",               # Two decimal places
    cmap="RdBu_r",           # Diverging colormap centered on 0
    vmin=-1, vmax=1,         # Fixed scale for consistency
    square=True,             # Square cells
    linewidths=0.5,
    ax=ax
)

ax.set_title("E-commerce Metrics Correlation")
plt.tight_layout()
plt.savefig("correlation_heatmap.png", dpi=150)
plt.show()
```

La seleccion del colormap `RdBu_r` responde a un principio de diseno: los mapas de colores divergentes asignan tonos opuestos a correlaciones positivas y negativas, con blanco en el centro para la correlacion nula. Los parametros `vmin=-1` y `vmax=1` fijan la escala para que la intensidad del color sea comparable entre distintos conjuntos de datos, evitando que una correlacion moderada de 0.4 se represente con la misma intensidad que una de 0.95 simplemente porque es el maximo del dataset actual.

En el contexto de este ejemplo, la correlacion entre page_views y time_on_site es fuerte porque la segunda variable fue generada como funcion lineal de la primera. La relacion entre cart_adds y purchases refleja el embudo de conversion del comercio electronico. Articular estas observaciones durante una entrevista -- conectar los numeros con la logica del negocio -- es lo que distingue a un analista tecnico de alguien que solo ejecuta codigo.

## Estilos profesionales y temas de Seaborn

La apariencia por defecto de Matplotlib cumple su funcion pero no comunica profesionalismo. En una entrevista, un grafico con tipografia generica, fondo gris y colores predeterminados transmite falta de atencion al detalle. Seaborn proporciona un sistema de temas que transforma el aspecto de todos los graficos con una sola llamada.

```python
# professional_styling.py
import matplotlib.pyplot as plt
import seaborn as sns

# Apply Seaborn's built-in theme
sns.set_theme(
    style="whitegrid",       # Clean background with grid lines
    palette="muted",         # Professional color palette
    font_scale=1.1           # Slightly larger text
)

# Global Matplotlib overrides
plt.rcParams.update({
    "figure.facecolor": "white",
    "axes.facecolor": "white",
    "font.family": "sans-serif",
    "axes.titlesize": 14,
    "axes.labelsize": 12,
})
```

El estilo `"whitegrid"` genera un fondo blanco con lineas de cuadricula sutiles que facilitan la lectura de valores sin agregar ruido visual. La paleta `"muted"` ofrece colores con saturacion moderada, apropiados para presentaciones corporativas y reportes ejecutivos. El parametro `font_scale=1.1` incrementa ligeramente el tamano de toda la tipografia, mejorando la legibilidad en pantallas de proyeccion.

Las sobrecargas de `plt.rcParams` permiten afinar aspectos que Seaborn no controla directamente, como la familia tipografica o los tamanos especificos de titulo y etiqueta. Colocar esta configuracion al inicio de un script o notebook garantiza consistencia visual en todas las figuras generadas durante la sesion.

> **Funciones obsoletas en Seaborn 0.13**
>
> A partir de Seaborn 0.12, funciones como `distplot()` y `factorplot()` fueron eliminadas definitivamente. Las alternativas actuales son `displot()`, `histplot()` y `catplot()`. Utilizar funciones obsoletas en una entrevista indica desactualizacion respecto a las versiones recientes de la biblioteca y puede generar errores de ejecucion que consumen tiempo valioso de la prueba.

## Preguntas conceptuales frecuentes en entrevistas

Ademas de los ejercicios de codigo, las entrevistas de data analytics incluyen preguntas teoricas sobre visualizacion. Responderlas con precision demuestra comprension de los fundamentos detras de cada decision grafica.

**Grafico de barras versus grafico de linea: criterio de seleccion.** Las barras son apropiadas para comparar magnitudes entre categorias discretas (departamentos, regiones, productos). Las lineas representan tendencias a lo largo de una dimension continua, tipicamente el tiempo. Utilizar barras para una serie temporal de 24 meses satura el grafico y dificulta la identificacion de la tendencia; una linea con marcadores es la eleccion correcta.

**Como se puede hacer un grafico enganoso, incluso sin intencion.** Truncar el eje Y para que no comience en cero exagera las diferencias entre valores. Utilizar escalas logaritmicas sin indicarlo comprime variaciones grandes. Elegir colores demasiado similares impide distinguir categorias. Presentar demasiadas series en un solo grafico genera ruido visual. En una entrevista, identificar estos patrones demuestra criterio analitico.

**Paletas de colores y accesibilidad.** Aproximadamente el 8% de la poblacion masculina presenta algun grado de daltonismo. Seaborn incluye la paleta `"colorblind"` disenada para mantener la distinguibilidad en estas condiciones. Complementar el color con marcadores, patrones o anotaciones textuales garantiza que la informacion sea accesible para todos los lectores.

**`plt.show()` versus `plt.savefig()`: orden y comportamiento.** `plt.savefig()` debe invocarse antes de `plt.show()` porque este ultimo limpia la figura en algunos backends. Omitir `dpi=150` o un valor superior genera imagenes de baja resolucion que se pixelan al incluirlas en presentaciones o documentos.

## Ejercicio integrador: dashboard de metricas de producto

Este ejercicio replica una prueba tecnica real donde se solicita construir un dashboard con tres paneles que presenten diferentes perspectivas del desempeno de un producto. Combina graficos de linea, barras y una linea de referencia horizontal, aplicando los estilos profesionales configurados anteriormente.

El dashboard incluye tres metricas clave: tendencia de ingresos, crecimiento acumulado de clientes y tasa de cancelacion mensual con un objetivo de referencia. Cada panel emplea un tipo de grafico distinto, demostrando versatilidad tecnica.

```python
# interview_exercise.py
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import numpy as np

sns.set_theme(style="whitegrid", palette="muted", font_scale=1.05)

# Simulate 12 months of product data
np.random.seed(42)
months = pd.date_range("2025-01", periods=12, freq="MS")
df = pd.DataFrame({
    "month": months,
    "revenue": np.cumsum(np.random.normal(5000, 2000, 12)) + 50_000,
    "customers": np.cumsum(np.random.poisson(50, 12)) + 500,
    "churn_rate": np.clip(np.random.normal(0.05, 0.015, 12), 0.01, 0.12)
})

fig, axes = plt.subplots(1, 3, figsize=(18, 5))

# Panel 1: Revenue trend
axes[0].plot(df["month"], df["revenue"], marker="o", color="#2563eb")
axes[0].set_title("Revenue Trend")
axes[0].set_ylabel("Revenue (USD)")
axes[0].yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"${x:,.0f}"))
axes[0].tick_params(axis="x", rotation=45)
axes[0].spines[["top", "right"]].set_visible(False)

# Panel 2: Customer growth
axes[1].bar(df["month"], df["customers"], color="#16a34a", width=20)
axes[1].set_title("Customer Growth")
axes[1].set_ylabel("Total Customers")
axes[1].tick_params(axis="x", rotation=45)
axes[1].spines[["top", "right"]].set_visible(False)

# Panel 3: Churn rate with threshold line
axes[2].plot(df["month"], df["churn_rate"], marker="s", color="#dc2626")
axes[2].axhline(y=0.05, color="gray", linestyle="--", label="Target: 5%")
axes[2].set_title("Monthly Churn Rate")
axes[2].set_ylabel("Churn Rate")
axes[2].yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f"{x:.1%}"))
axes[2].tick_params(axis="x", rotation=45)
axes[2].spines[["top", "right"]].set_visible(False)
axes[2].legend()

fig.suptitle("Product Dashboard — FY 2025", fontsize=14, fontweight="bold")
plt.tight_layout()
plt.savefig("interview_dashboard.png", dpi=150)
plt.show()
```

El primer panel utiliza un grafico de linea con marcadores para la tendencia de ingresos, enfatizando la direccion del crecimiento mes a mes. El segundo emplea barras para el total acumulado de clientes, donde la altura creciente comunica visualmente la trayectoria de adquisicion. El tercer panel introduce una linea horizontal de referencia con `axhline` al 5%, que transforma un numero abstracto en una evaluacion de desempeno: los meses por encima de la linea indican un churn superior al objetivo operativo.

Durante la entrevista, se espera que el candidato articule por que se eligio cada tipo de grafico. Un grafico de linea enfatiza la continuidad temporal del ingreso. Las barras son apropiadas para valores acumulativos porque la altura absoluta de cada barra tiene significado propio. La linea de referencia agrega contexto que permite evaluar el desempeno sin necesidad de consultar una tabla de objetivos por separado.

## Conclusion

Prepararse para ejercicios de visualizacion en entrevistas de data analytics requiere tanto dominio tecnico de las bibliotecas como criterio para tomar decisiones de diseno que comuniquen con claridad. Los puntos centrales de esta guia son:

- La API orientada a objetos de Matplotlib (`fig, ax = plt.subplots()`) proporciona control explicito sobre cada elemento del grafico y es el estandar esperado en entrevistas
- Seaborn simplifica la creacion de graficos estadisticos a partir de DataFrames, pero las personalizaciones avanzadas requieren combinarla con Matplotlib
- Los subplots permiten construir dashboards con multiples metricas en una sola figura, demostrando capacidad de sintesis analitica
- Los heatmaps de correlacion exigen escalas fijas (`vmin=-1`, `vmax=1`) y colormaps divergentes para ser interpretables sin ambiguedad
- Los estilos profesionales con `sns.set_theme()` y `plt.rcParams` transforman la apariencia de los graficos con esfuerzo minimo
- Cada grafico debe incluir etiquetas de ejes con unidades, titulo descriptivo y formato numerico legible
- La explicacion verbal de las decisiones de diseno tiene el mismo peso que el codigo funcional en una evaluacion tecnica

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/es/blog/data-analytics/python-matplotlib-seaborn-data-visualization-interview