## 🎯 Apertura Magistral: ¿Por Qué Visualizar Datos?

El Poder de la Imagen en la Era

de la Información

En el vasto océano de datos que caracteriza nuestro mundo moderno, los números
crudos, las tablas extensas y las hojas de cálculo pueden resultar abrumadores e
incluso opacos. El cerebro humano, sin embargo, está extraordinariamente adaptado
para procesar información visual. Una imagen bien diseñada puede transmitir
patrones complejos, tendencias, anomalías y relaciones de manera casi instantánea,
algo que requeriría páginas de descripción textual o análisis numérico para lograr.

**El Problema Fundamental:** Los datos, por sí solos, no cuentan historias.

Necesitan ser interpretados, contextualizados y comunicados. La visualización de
datos es el puente entre la información cuantitativa y la comprensión cualitativa.

**Matplotlib como Solución:** Matplotlib emerge como una de las bibliotecas más
fundamentales y versátiles en el ecosistema científico de Python para la creación
de gráficos estáticos, animados e interactivos. Su poder reside en ofrecer un
control granular sobre prácticamente todos los aspectos de un gráfico, permitiendo
la creación de visualizaciones con calidad de publicación. Aprender Matplotlib no
es solo aprender a "dibujar gráficos", es adquirir una herramienta esencial para:
1. **Explorar Datos (Análisis Exploratorio de Datos - EDA):** Descubrir patrones,
identificar valores atípicos, probar hipótesis y obtener intuiciones iniciales.
2. **Comunicar Resultados:** Presentar hallazgos de manera clara, concisa y
convincente a diversas audiencias.
3. **Depurar Modelos:** Visualizar el rendimiento de algoritmos, errores, o la
evolución de procesos.

**Principios Fundamentales que Guiaremos:**

* **Abstracción:** Entenderemos cómo Matplotlib modela un gráfico a través de
objetos jerárquicos como `Figure` y `Axes`.
* **Modularidad:** Aprenderemos a construir gráficos complejos combinando
componentes personalizables.
* **Control Programático:** Dominaremos la capacidad de generar y modificar
visualizaciones mediante código, lo que permite la reproducibilidad y la
automatización.

**Hoja de Ruta de Nuestro Viaje:**

1. **La Anatomía de un Gráfico:** Desglosaremos los componentes esenciales de
cualquier visualización.
2. **El Ecosistema Matplotlib:** Introduciremos `pyplot` y el poderoso paradigma
orientado a objetos.
3. **Creación de Gráficos Paso a Paso:** Desde los datos hasta la imagen final.
4. **Personalización Detallada:** Dominando colores, estilos, etiquetas, leyendas
y más.
5. **Un Catálogo de Visualizaciones:** Explorando los tipos de gráficos más
comunes y cuándo usarlos.
6. **Composiciones Avanzadas:** Múltiples gráficos en una figura, y funciones para
la eficiencia.
7. **Integración con Pandas:** Visualizando datos directamente desde DataFrames.

Este no es solo un apunte sobre una biblioteca; es una invitación a pensar

visualmente sobre los datos y a dominar una habilidad crucial para cualquier
profesional que trabaje con información.

---

## 🧭 Desarrollo Conceptual Progresivo: La Arquitectura de una Visualización en

Matplotlib
Antes de escribir nuestra primera línea de código para trazar un gráfico, es
crucial entender cómo Matplotlib concibe y organiza una visualización. Esta
comprensión es la base para un control efectivo y para la creación de gráficos
complejos.

### La Jerarquía de Objetos de Matplotlib

Matplotlib organiza los gráficos en una jerarquía de objetos Python. Los dos
objetos más importantes con los que interactuaremos constantemente son la
**`Figure`** y los **`Axes`**.

**Idea Visual: Jerarquía de Matplotlib**

* **Descripción:** Un diagrama de cajas anidadas. La caja exterior más grande se
etiqueta como `Figure` (el lienzo completo). Dentro de esta, puede haber una o más
cajas etiquetadas como `Axes` (gráficos individuales). Cada `Axes` contiene
elementos como `X-Axis`, `Y-Axis`, `Plot Lines`, `Title`, `Legend`, etc. Los `X-
Axis` y `Y-Axis` a su vez gestionan `Ticks` (marcas) y `Tick Labels` (etiquetas de
las marcas).
* **Clarificación:** Este diagrama ilustra que una `Figure` es el contenedor de
todo, y los `Axes` son los "cuadros" individuales donde se dibujan los datos.

🎨 **Código para Diagrama ([Link] - Jerarquía Simplificada):**

```mermaid
graph TD
A[Figure: El Contenedor Global] --> B(Axes 1: Gráfico Individual);
A --> C(Axes 2: Otro Gráfico Individual ...opcional);
B --> B1[X-Axis];
B --> B2[Y-Axis];
B --> B3[Elementos del Gráfico: Líneas, Puntos, Barras];
B --> B4[Componentes: Título, Leyenda, Grilla];
B1 --> B1a[Ticks (Marcas)];
B1 --> B1b[Tick Labels (Etiquetas de Marcas)];
B1 --> B1c[Axis Label (Etiqueta del Eje X)];
B2 --> B2a[Ticks (Marcas)];
B2 --> B2b[Tick Labels (Etiquetas de Marcas)];
B2 --> B2c[Axis Label (Etiqueta del Eje Y)];

style A fill:#ECECFF,stroke:#9370DB,stroke-width:2px
style B fill:#FFF0F5,stroke:#FF69B4,stroke-width:2px
style C fill:#FFF0F5,stroke:#FF69B4,stroke-width:2px
```

🧠 **Definiciones Fundamentales:**

1. **`Figure` (Figura):**
* **Motivación/Intuición:** Piensa en la `Figure` como el lienzo completo o
la ventana sobre la cual se dibuja todo. Es el contenedor de más alto nivel para
todos los elementos del gráfico.
* **Definición Formal/Conceptual:** Un objeto `[Link]` es
la instancia que rastrea todos los `Axes` (subgráficos), un grupo de artistas
"especiales" (títulos, leyendas de figura, barras de color, etc.), y el lienzo
mismo. Una figura puede contener cualquier número de `Axes`, pero un `Axes` solo
puede estar en una `Figure`.
* **Justificación:** Necesitamos un objeto global para gestionar el tamaño
general, el color de fondo, y para guardar la visualización completa en un archivo.

2. **`Axes` (Ejes, pero se refiere a un Subgráfico):**

* **Motivación/Intuición:** Si la `Figure` es el lienzo, un `Axes` es una
región particular de ese lienzo donde trazamos los datos. Es lo que comúnmente
pensaríamos como "un gráfico" o "un plot".
* **Definición Formal/Conceptual:** Un objeto `[Link]` es la
región de la imagen con el espacio de datos. Un `Axes` dado contiene dos (o tres en
3D) objetos `Axis` (que se encargan de los ejes de datos) y define el sistema de
coordenadas. Es donde se realizan la mayoría de las operaciones de trazado:
`plot()`, `scatter()`, `bar()`, etc., son métodos de un objeto `Axes`.
* **Justificación:** Permite tener múltiples gráficos (subgráficos) dentro de
una sola figura, cada uno con sus propios datos, sistema de coordenadas y
personalizaciones.
* ⚠️ **¡Ojo! `Axes` (plural, con 'e') no es lo mismo que `Axis` (singular).**
Un objeto `Axes` contiene objetos `Axis`.

3. **`Axis` (Eje):**
* **Motivación/Intuición:** Son las "reglas" numeradas a los lados del
gráfico. Controlan cómo se mapean los datos a los píxeles del gráfico.
* **Definición Formal/Conceptual:** Objetos `[Link]` que se
encargan de establecer los límites del gráfico, generar las marcas (ticks) en los
ejes y las etiquetas de esas marcas. Por ejemplo, `[Link]` y `[Link]` son
instancias de `Axis`.
* **Justificación:** Proporcionan control fino sobre la escala, la apariencia
de las marcas y las etiquetas de cada eje dimensional (X, Y, y Z para 3D).

### El Módulo `pyplot`: Dos Enfoques para Graficar

Matplotlib ofrece dos interfaces principales para crear gráficos:

1. **La Interfaz `pyplot` (Estilo MATLAB):**

* `[Link]` es una colección de funciones que hacen que Matplotlib
funcione como MATLAB. Cada función de `pyplot` realiza algún cambio en una figura:
por ejemplo, crea una figura, crea un área de trazado en una figura, traza algunas
líneas en un área de trazado, decora el trazado con etiquetas, etc.
* `pyplot` mantiene un estado interno: rastrea la figura y los axes
"actuales". Las funciones de `pyplot` operan sobre estos objetos implícitos.
* **Ejemplo (implícito):**
```python
import [Link] as plt
[Link]([1, 2, 3], [4, 5, 1])
[Link]("Eje X")
[Link]()
```
* **Ventaja:** Rápido y conveniente para gráficos simples y exploración
interactiva.
* **Desventaja:** Menos explícito. Puede volverse confuso cuando se trabaja
con múltiples figuras o axes, o cuando se necesita un control más detallado y
reutilizable.

2. **La Interfaz Orientada a Objetos (API OO):**

* Esta es la forma más robusta y flexible. Se crean explícitamente objetos
`Figure` y `Axes`, y luego se llaman métodos directamente sobre estos objetos.
* **Ejemplo (explícito):**
```python
import [Link] as plt
fig, ax = [Link]() # Crea una figura Y un conjunto de axes
[Link]([1, 2, 3], [4, 5, 1])
ax.set_xlabel("Eje X")
[Link]()
```
* **Ventaja:** Mucho más control y claridad, especialmente para gráficos
complejos, múltiples subplots, o cuando se integran gráficos en aplicaciones más
grandes. Es más "pythónico".
* **Desventaja:** Ligeramente más verboso para gráficos muy simples.

**Recomendación Pedagógica:**
Para aprender Matplotlib de manera sólida y prepararse para escenarios más
complejos, **nos enfocaremos principalmente en la interfaz orientada a objetos**.
La función `[Link]()` es la forma más conveniente de comenzar con el API OO.
Aunque usaremos `plt` para funciones globales como `[Link]()` o `[Link]()`
(ocasionalmente), la mayoría de las operaciones de trazado y personalización las
haremos a través de métodos del objeto `ax` (o `axes`).

El material fuente menciona `[Link]()` y `[Link]()`.

* `[Link]()`: Crea un objeto `Figure` vacío. Luego necesitarías añadir `Axes`
manualmente (ej. `ax = fig.add_subplot(1, 1, 1)`).
* `[Link]()`: Es una función de conveniencia que crea una `Figure` y un
conjunto de `Axes` (subgráficos) de una sola vez, y los devuelve. Es la forma más
común y recomendada de iniciar un gráfico.
```python
fig, ax = [Link]() # Por defecto, crea una figura con UN solo Axes
# fig es el objeto Figure
# ax es el objeto Axes
```
Si quisiéramos, por ejemplo, 2 filas y 3 columnas de subplots:
```python
fig, axs = [Link](2, 3) # axs será un array 2x3 de objetos Axes
# axs[0, 0] es el Axes en la primera fila, primera columna
```

Esta base conceptual nos permitirá abordar la creación y personalización de

gráficos de manera estructurada y potente.

---
## ⚙️ Creación de Gráficos: Un Flujo de Trabajo Sistemático

Crear una visualización efectiva con Matplotlib sigue un flujo de trabajo lógico.
Comprender estos pasos te permitirá abordar cualquier tarea de graficación con
confianza.

**Idea Visual: Flujo de Trabajo para Crear un Gráfico en Matplotlib**

* **Descripción:** Un diagrama de flujo simple.
1. Inicio: "Preparar Datos".
2. Paso 1: "Crear `Figure` y `Axes`" (usando `[Link]()`).
3. Paso 2: "Trazar Datos en `Axes`" (usando métodos como `[Link]()`,
`[Link]()`, etc.).
4. Paso 3: "Personalizar el Gráfico" (títulos, etiquetas, leyendas, colores,
estilos, etc., usando métodos de `ax`).
5. Paso 4: "Mostrar o Guardar" (usando `[Link]()` o `[Link]()`).
6. Fin.
* **Clarificación:** Este flujo destaca la secuencia de acciones, desde la
preparación de los datos hasta la visualización final.

🎨 **Código para Diagrama ([Link] - Flujo de Trabajo Básico):**

```mermaid
graph TD
A[Preparar Datos] --> B{Crear Figura y Axes};
B -- fig, ax = [Link]() --> C{Trazar Datos en Axes};
C -- [Link](x, y), etc. --> D{Personalizar Gráfico};
D -- ax.set_title(), ax.set_xlabel(), etc. --> E{Mostrar o Guardar};
E -- [Link]() / [Link]() --> F[Fin];
 style A fill:#E6E6FA,stroke:#483D8B
style B fill:#ADD8E6,stroke:#00008B
style C fill:#90EE90,stroke:#006400
style D fill:#FFDAB9,stroke:#A0522D
style E fill:#F08080,stroke:#8B0000
style F fill:#D3D3D3,stroke:#696969
```

### Paso 0: Preparar los Datos

Antes de que Matplotlib pueda hacer su magia, necesitas tener los datos que quieres
visualizar. Estos datos suelen estar en forma de secuencias Python:
* Listas de Python: `[1, 2, 3, 4]`
* Arrays de NumPy: `[Link]([1, 2, 3, 4])`
* Series o columnas de DataFrames de Pandas.

**Ejemplo de Datos:**
Supongamos que queremos graficar la temperatura a lo largo de varios días.
```python
dias = [1, 2, 3, 4, 5, 6, 7] # Eje X: Días
temperaturas = [15, 17, 16, 18, 19, 18, 17] # Eje Y: Temperaturas en °C
```

### Paso 1: Crear la `Figure` y los `Axes`

Como discutimos, la forma más común y recomendada es usar `[Link]()`.

```python
import [Link] as plt

fig, ax = [Link]()
# 'fig' es nuestro lienzo (Figure).
# 'ax' es nuestro único conjunto de ejes (Axes) donde dibujaremos.
```
* **¿Qué sucede aquí?** `[Link]()` crea una nueva `Figure` y, por defecto,
le añade un solo `Axes`. Devuelve ambos en una tupla, que desempaquetamos en las
variables `fig` y `ax`.
* **¿Por qué esta forma?** Nos da acceso explícito tanto a la figura completa
como al área de trazado específica. Esto es crucial para la personalización y para
manejar múltiples subplots.

### Paso 2: Trazar los Datos en los `Axes`

Una vez que tenemos nuestro objeto `ax` (el `Axes`), podemos usar sus métodos para
dibujar los datos. El método más fundamental para gráficos de líneas es
`[Link]()`.
```python
# (Continuación del código anterior)
# dias = [1, 2, 3, 4, 5, 6, 7]
# temperaturas = [15, 17, 16, 18, 19, 18, 17]

[Link](dias, temperaturas)
```
* **`[Link](x, y)`:** Toma dos argumentos principales:
* `x`: Una secuencia de valores para el eje horizontal.
* `y`: Una secuencia de valores para el eje vertical.
* **Importante:** `x` e `y` deben tener la misma longitud. Matplotlib
emparejará el primer elemento de `x` con el primero de `y`, el segundo con el
segundo, y así sucesivamente, para crear puntos `(x, y)` que luego unirá con
líneas.

### Paso 3: Personalizar el Gráfico (Lo Básico)

Un gráfico sin etiquetas ni título es poco informativo. Usemos métodos del objeto
`ax` para añadir estos elementos esenciales:
```python
# (Continuación)
ax.set_title("Temperatura Semanal")
ax.set_xlabel("Día de la Semana")
ax.set_ylabel("Temperatura (°C)")
```
* `ax.set_title("...")`: Establece el título del `Axes`.
* `ax.set_xlabel("...")`: Establece la etiqueta para el eje X.
* `ax.set_ylabel("...")`: Establece la etiqueta para el eje Y.

Exploraremos muchas más opciones de personalización en breve.

### Paso 4: Mostrar o Guardar el Gráfico

Finalmente, para ver nuestro gráfico, usamos `[Link]()`. Si quisiéramos guardarlo

en un archivo, usaríamos `[Link]()`.
```python
# (Continuación)
[Link]() # Muestra el gráfico en una ventana o inline (en Jupyter/Colab)

# Para guardar la figura en un archivo:

# [Link]("temperatura_semanal.png")
# [Link]("temperatura_semanal.pdf") # Muchos formatos soportados
```
* **`[Link]()`:** Es una función de `pyplot` que busca todas las figuras
activas, las dibuja y, en entornos interactivos, las muestra. En scripts, bloquea
la ejecución hasta que se cierra la ventana del gráfico.
* **`[Link]("nombre_archivo.ext")`:** Es un método del objeto `Figure`.
Guarda la figura completa en un archivo. La extensión del archivo (`.png`, `.jpg`,
`.pdf`, `.svg`, etc.) determina el formato.

### 💻 Código Completo del Primer Gráfico:

```python
import [Link] as plt

# Paso 0: Preparar los Datos

dias = [1, 2, 3, 4, 5, 6, 7]
temperaturas = [15, 17, 16, 18, 19, 18, 17]

# Paso 1: Crear la Figure y los Axes

fig, ax = [Link]()

# Paso 2: Trazar los Datos en los Axes

[Link](dias, temperaturas)

# Paso 3: Personalizar el Gráfico

ax.set_title("Temperatura Semanal")
ax.set_xlabel("Día de la Semana")
ax.set_ylabel("Temperatura (°C)")

# Paso 4: Mostrar el Gráfico

[Link]()
```

Este flujo de trabajo es la base para todos los gráficos que crearemos. A medida
que avanzamos, el "Paso 2" involucrará diferentes métodos de trazado (`scatter`,
`bar`, etc.) y el "Paso 3" se volverá mucho más rico y detallado.

💊 **Puntos Clave de Repaso:**

* La creación de gráficos sigue un flujo: Datos $\rightarrow$ Figura/Axes $\
rightarrow$ Trazado $\rightarrow$ Personalización $\rightarrow$ Mostrar/Guardar.
* `[Link]()` es la forma recomendada de obtener los objetos `fig` y `ax`.
* `[Link](x, y)` es el comando básico para gráficos de líneas.
* `ax.set_title()`, `ax.set_xlabel()`, `ax.set_ylabel()` añaden información
esencial.
* `[Link]()` visualiza el gráfico.

---
## 🎨 Personalización Detallada: Dando Vida y Claridad a tus Gráficos

Un gráfico básico muestra los datos, pero un gráfico *excelente* los comunica de
manera efectiva y estética. Matplotlib ofrece un control exhaustivo sobre casi
todos los elementos de una figura. Nos centraremos en las personalizaciones más
comunes y útiles que se aplican a través de métodos del objeto `Axes` (`ax`) o como
parámetros en las funciones de trazado.

La documentación oficial de Matplotlib tiene una famosa imagen llamada "Anatomy of

a figure" que desglosa todos los componentes. La puedes encontrar buscando
"matplotlib anatomy of a figure". Aquí, explicaremos cómo controlar muchos de esos
componentes.

### 1. Colores, Estilos de Línea y Marcadores (en `[Link]()`)

Cuando llamas a `[Link](x, y, ...)`, puedes pasar argumentos adicionales para

controlar la apariencia de la línea.

```python
import [Link] as plt
import numpy as np # Usaremos NumPy para generar datos más interesantes

# Datos de ejemplo
x = [Link](0, 10, 100) # 100 puntos entre 0 y 10
y1 = [Link](x)
y2 = [Link](x)

fig, ax = [Link]()

# Línea 1: Sinusoide
[Link](x, y1,
color='blue', # Color de la línea (nombre, hex, RGB)
linestyle='-', # Estilo de línea: '-', '--', '-.', ':' o 'solid',
'dashed', etc.
linewidth=2, # Grosor de la línea
marker='o', # Estilo del marcador en cada punto de datos: '.',
'o', 'v', '^', '<', '>', 's', 'p', '*', etc.
markersize=5, # Tamaño del marcador
label='Seno(x)') # Etiqueta para la leyenda (ver más adelante)

# Línea 2: Cosenusoide
[Link](x, y2,
color='red',
 linestyle='--',
linewidth=1.5,
marker='x',
markersize=7,
label='Coseno(x)')

# Añadimos títulos y etiquetas

ax.set_title("Funciones Trigonométricas")
ax.set_xlabel("X")
ax.set_ylabel("Y")

# Para que las etiquetas 'label' aparezcan, necesitamos una leyenda

[Link]()

[Link]()
```

**Parámetros Clave de `[Link]()` para Estilo:**

* `color`: Especifica el color. Puede ser un nombre (`'green'`), una abreviatura
(`'g'`), un código hexadecimal (`'#FF5733'`), o una tupla RGB(A) (`(0.1, 0.2,
0.5)`).
* `linestyle` (o `ls`): Define el estilo de la línea.
* `'-'` o `'solid'` (por defecto)
* `'--'` o `'dashed'`
* `'-.'` o `'dashdot'`
* `':'` o `'dotted'`
* `linewidth` (o `lw`): Un número que especifica el grosor de la línea.
* `marker`: El símbolo a usar en cada punto de dato. Hay muchos disponibles
(`'o'` para círculo, `'s'` para cuadrado, `'^'` para triángulo, etc.).
* `markersize` (o `ms`): Tamaño del marcador.
* `markeredgecolor`, `markerfacecolor`: Colores para el borde y relleno del
marcador.
* `label`: Texto que se usará en la leyenda para identificar esta línea.

🔗 **Referencia:** Para una lista completa de estilos de línea y marcadores,

consulta la documentación de `[Link]`.

### 2. Títulos y Etiquetas de Ejes (Revisado)

Ya vimos `ax.set_title()`, `ax.set_xlabel()`, `ax.set_ylabel()`. Estos métodos

también aceptan parámetros para personalizar la fuente:
```python
ax.set_title("Título del Gráfico", fontsize=16, fontweight='bold',
color='darkblue')
ax.set_xlabel("Etiqueta Eje X", fontsize=12, fontstyle='italic')
ax.set_ylabel("Etiqueta Eje Y", fontsize=12, color='#555555')
```
* `fontsize`: Tamaño de la fuente en puntos.
* `fontweight`: Grosor de la fuente (`'normal'`, `'bold'`, `'light'`, etc.).
* `fontstyle`: Estilo de la fuente (`'normal'`, `'italic'`, `'oblique'`).
* `color`: Color del texto.

### 3. Leyendas (`[Link]()`)

Cuando tienes múltiples líneas o conjuntos de datos en un solo `Axes`, una leyenda
es crucial para identificarlos.
1. **Añade el argumento `label`** a cada llamada de `[Link]()` (o `[Link]()`,
etc.).
2. **Llama a `[Link]()`** después de haber trazado todos los elementos.
```python
# ... (código anterior con [Link](..., label='Seno(x)')) ...
# ... (código anterior con [Link](..., label='Coseno(x)')) ...

[Link](loc='upper right', fontsize=10, frameon=True, shadow=True)

# loc: Ubicación de la leyenda ('best', 'upper right', 'lower left', etc.)
# fontsize: Tamaño de fuente de la leyenda.
# frameon: Booleano, si se dibuja un marco alrededor de la leyenda.
# shadow: Booleano, si se dibuja una sombra detrás del marco.
[Link]()
```
* **`loc` (location):** Es un parámetro importante. `'best'` intenta encontrar la
ubicación menos obstructiva. Otras opciones comunes: `'upper right'`, `'upper
left'`, `'lower right'`, `'lower left'`, `'center'`, etc.

### 4. Grilla o Cuadrícula (`[Link]()`)

Una grilla puede ayudar a leer los valores del gráfico con mayor precisión.
```python
[Link](True) # Activa la grilla para ambos ejes
```
Puedes personalizarla:
```python
[Link](True,
which='major', # 'major', 'minor', or 'both'
axis='both', # 'x', 'y', or 'both'
color='gray',
linestyle=':',
linewidth=0.5)
[Link]()
```
* `which`: A qué ticks aplicar la grilla (los ticks mayores son los principales,
los menores son subdivisiones).
* `axis`: En qué eje dibujar la grilla.

### 5. Límites de los Ejes (`ax.set_xlim()`, `ax.set_ylim()`)

Por defecto, Matplotlib ajusta los límites de los ejes para que se ajusten a tus
datos. A veces, querrás establecerlos explícitamente.
```python
ax.set_xlim(0, 10) # Límites para el eje X: de 0 a 10
ax.set_ylim(-1.5, 1.5) # Límites para el eje Y: de -1.5 a 1.5
[Link]()
```
Esto es útil para asegurar consistencia entre múltiples gráficos o para enfocarse
en una región particular.

### 6. Ticks de los Ejes (`ax.set_xticks()`, `ax.set_yticks()`,

`ax.set_xticklabels()`, `ax.set_yticklabels()`)

Los "ticks" son las marcas en los ejes. Puedes controlar sus posiciones y
etiquetas.
```python
# Establecer las posiciones de los ticks mayores en el eje X
ax.set_xticks([0, [Link], 2*[Link], 3*[Link]]) # Poner ticks en 0, pi, 2pi, 3pi

# Establecer las etiquetas para esos ticks (pueden ser strings)

ax.set_xticklabels(['0', '$\pi$', '$2\pi$', '$3\pi$'], fontsize=12) # Usando KaTeX
para símbolos

# Para el eje Y, podemos rotar las etiquetas

ax.set_yticks([-1, 0, 1])
ax.set_yticklabels(['Min', 'Cero', 'Max'], rotation=45)

[Link]()
```
* `ax.set_xticks([pos1, pos2, ...])`: Define las ubicaciones de los ticks.
* `ax.set_xticklabels([lab1, lab2, ...])`: Define las etiquetas para esos ticks.
Deben corresponder en número a los ticks definidos.
* Se pueden usar expresiones KaTeX (encerradas en `$`) para formateo matemático
en las etiquetas.
* `rotation`: Gira las etiquetas de los ticks.

### 7. Tamaño de la Figura (`figsize` en `[Link]()`)

Puedes controlar el tamaño de la figura (el lienzo completo) al crearla.

```python
fig, ax = [Link](figsize=(10, 6)) # Ancho=10 pulgadas, Alto=6 pulgadas
# ... resto del código de trazado ...
[Link]()
```
Esto es útil para asegurar que el gráfico tenga suficiente espacio, especialmente
si tiene muchos elementos o subplots.

### 💻 Ejemplo Integrador de Personalización:

```python
import [Link] as plt
import numpy as np

# Datos
x = [Link](0, 2 * [Link], 200)
y_sin = [Link](x)
y_cos = [Link](x)
y_tan_approx = [Link](x) / ([Link](x) + 0.1) # Aproximación para evitar asíntotas
extremas

# Crear Figura y Axes con tamaño específico

fig, ax = [Link](figsize=(12, 7))

# Trazar datos con personalización

[Link](x, y_sin, color='dodgerblue', linestyle='-', linewidth=2.5, marker='o',
markersize=5, markeredgecolor='black', label='Seno(x)')
[Link](x, y_cos, color='orangered', linestyle='--', linewidth=2.5, marker='^',
markersize=6, label='Coseno(x)')
[Link](x, y_tan_approx, color='green', linestyle=':', linewidth=2, label='Tangente
Aprox.(x)')

# Títulos y Etiquetas con formato

ax.set_title("Funciones Trigonométricas Avanzadas", fontsize=18, fontweight='bold',
color='navy')
ax.set_xlabel("Ángulo (radianes)", fontsize=14, fontstyle='italic')
ax.set_ylabel("Valor de la Función", fontsize=14)

# Límites de los ejes

ax.set_xlim(0, 2 * [Link])
ax.set_ylim(-2, 2) # Ajustar para la tangente aproximada
# Ticks personalizados para el eje X
major_ticks_x = [Link]([0, [Link]/2, [Link], 3*[Link]/2, 2*[Link]])
major_tick_labels_x = ['$0$', r'$\frac{\pi}{2}$', r'$\pi$', r'$\frac{3\pi}{2}$',
r'$2\pi$']
ax.set_xticks(major_ticks_x)
ax.set_xticklabels(major_tick_labels_x, fontsize=12)

# Ticks personalizados para el eje Y

ax.set_yticks([Link](-2, 2.1, 0.5)) # Ticks de -2 a 2, con paso 0.5

# Leyenda
[Link](loc='upper right', fontsize=11, frameon=True, shadow=True, borderpad=1)

# Grilla
[Link](True, linestyle='--', alpha=0.7) # alpha para transparencia

# Añadir una línea horizontal en y=0 para referencia

[Link](0, color='black', linewidth=0.75, linestyle='-')

# Añadir texto de anotación

[Link]([Link]/4, 1.5, "Región de Interés", fontsize=12, color='purple',
bbox=dict(boxstyle="round,pad=0.3", fc="yellow", ec="black", lw=1,
alpha=0.5))

plt.tight_layout() # Ajusta el padding para que todo quepa bien

[Link]()

# Guardar la figura
# [Link]("trigonometricas_avanzadas.png", dpi=300) # dpi para resolución
```

Este ejemplo muestra cómo combinar múltiples personalizaciones para crear un

gráfico informativo y visualmente atractivo. La clave es experimentar con los
parámetros y consultar la documentación de Matplotlib para descubrir aún más
opciones.

💊 **Puntos Clave de Repaso:**

* La personalización se realiza principalmente a través de métodos del objeto
`Axes` (`ax`) o parámetros en funciones de trazado.
* Elementos clave a personalizar: colores, estilos de línea, marcadores, títulos,
etiquetas de ejes, leyendas, grillas, límites de ejes y ticks.
* `figsize` en `[Link]()` controla el tamaño total de la figura.
* `[Link]()` es esencial cuando hay múltiples series de datos.
* `plt.tight_layout()` ayuda a que todos los elementos encajen bien.

---
## 📊 Un Catálogo de Visualizaciones: Eligiendo el Gráfico Adecuado

Matplotlib no se limita a gráficos de líneas. Ofrece una amplia gama de tipos de

gráficos, cada uno adecuado para visualizar diferentes tipos de datos y relaciones.
Aprenderemos a crear los más comunes y, lo más importante, a entender *cuándo* usar
cada uno.

En todos los casos, el flujo de trabajo general (Preparar Datos $\rightarrow$ Crear
Figura/Axes $\rightarrow$ Trazar $\rightarrow$ Personalizar $\rightarrow$
Mostrar/Guardar) sigue siendo el mismo. Lo que cambia es principalmente el método
de trazado del objeto `Axes` (ej. `[Link]()`, `[Link]()`, `[Link]()`, etc.).
### 1. Gráfico de Línea (`[Link]()`)

* **Propósito:** Visualizar tendencias y cambios en datos continuos a lo largo de

un intervalo o secuencia ordenada (a menudo tiempo o distancia). Muestra la
relación entre dos variables numéricas donde una depende de la otra o varía
secuencialmente.
* **Cuándo Usarlo:**
* Series temporales (evolución de precios, temperatura a lo largo del día).
* Datos científicos donde una variable se mide en función de otra continua
(espectros, curvas de calibración).
* Comparar tendencias de múltiples series.
* **Función Clave:** `[Link](x, y, ...)`
* **Ejemplo (ya visto extensamente):**
```python
import [Link] as plt
import numpy as np
x = [Link](0, 10, 50)
y = x**2
fig, ax = [Link]()
[Link](x, y, label='$y = x^2$', color='blue', marker='o')
ax.set_title("Gráfico de Línea: Función Cuadrática")
ax.set_xlabel("X")
ax.set_ylabel("Y = X^2")
[Link]()
[Link](True)
[Link]()
```

### 2. Gráfico de Dispersión o Puntos (`[Link]()`)

* **Propósito:** Mostrar la relación (o falta de ella) entre dos variables

numéricas. Cada punto en el gráfico representa una observación individual. Es
excelente para identificar correlaciones, agrupaciones (clusters) y valores
atípicos.
* **Cuándo Usarlo:**
* Investigar si existe una correlación lineal, no lineal o ninguna entre dos
conjuntos de mediciones (ej. altura vs. peso, gasto en publicidad vs. ventas).
* Identificar clusters de datos.
* Detectar outliers.
* **Función Clave:** `[Link](x, y, ...)`
* **Diferencia con `[Link](..., marker='o', linestyle='None')`:** `[Link]()`
ofrece más control sobre las propiedades de cada punto individualmente (ej. tamaño,
color, forma de cada punto puede variar según otra variable). `[Link]()` con solo
marcadores es más simple si todos los puntos tienen el mismo estilo.
* **Ejemplo:**
```python
import [Link] as plt
import numpy as np

# Datos simulados: Horas de estudio vs. Calificación en un examen

[Link](42) # Para reproducibilidad
horas_estudio = [Link](50) * 10 # 0 a 10 horas
calificaciones = 2 * horas_estudio + [Link](50) * 5 + 50 # Relación
lineal con ruido, base 50
calificaciones = [Link](calificaciones, 0, 100) # Asegurar que estén entre 0 y
100

# Tamaños y colores variables para los puntos (opcional, para mostrar

capacidad)
 esfuerzo_percibido = [Link](50) * 100 # Otra variable para el tamaño
satisfaccion = [Link](50) # Otra variable para el color

fig, ax = [Link](figsize=(8,6))
scatter_plot = [Link](horas_estudio, calificaciones,
s=esfuerzo_percibido, # 's' para tamaño del marcador
c=satisfaccion, # 'c' para color del marcador
(mapeado a un colormap)
cmap='viridis', # Colormap a usar
alpha=0.7, # Transparencia
edgecolors='black', # Color del borde de los
marcadores
label='Estudiantes')

ax.set_title("Gráfico de Dispersión: Horas de Estudio vs. Calificación")

ax.set_xlabel("Horas de Estudio")
ax.set_ylabel("Calificación Obtenida")
[Link](True, linestyle=':', alpha=0.5)

# Añadir una barra de color para la variable 'satisfaccion'

cbar = [Link](scatter_plot, label='Nivel de Satisfacción')

[Link]() # Aunque aquí 'label' en scatter es menos común si cada punto es

único
[Link]()
```

### 3. Gráfico de Barras (`[Link]()`, `[Link]()`)

* **Propósito:** Comparar cantidades discretas entre diferentes categorías. La

longitud (o altura) de cada barra es proporcional al valor que representa.
* **Cuándo Usarlo:**
* Comparar métricas entre grupos (ventas por producto, población por país).
* Mostrar la distribución de una variable categórica (frecuencia de cada
categoría).
* **Funciones Clave:**
* `[Link](categorias, valores, ...)`: Barras verticales.
* `[Link](categorias, valores, ...)`: Barras horizontales (útil si los
nombres de las categorías son largos).
* **Ejemplo:**
```python
import [Link] as plt

# Datos: Ventas de diferentes frutas (en kg)

frutas = ['Manzanas', 'Naranjas', 'Bananas', 'Uvas', 'Peras']
ventas_kg = [120, 95, 210, 80, 150]
colores = ['red', 'orange', 'yellow', 'purple', 'lightgreen']

fig, ax = [Link](figsize=(8,6))
bars = [Link](frutas, ventas_kg, color=colores, edgecolor='black')

ax.set_title("Ventas de Frutas por Kilogramo")

ax.set_xlabel("Tipo de Fruta")
ax.set_ylabel("Ventas (kg)")
ax.set_yticks([Link](0, max(ventas_kg) + 50, 25)) # Ajustar ticks del eje Y
[Link](axis='y', linestyle='--', alpha=0.7) # Grilla solo en el eje Y

# Añadir etiquetas de valor encima de cada barra

for bar in bars:
 yval = bar.get_height()
[Link](bar.get_x() + bar.get_width()/2.0, yval + 5, f'{yval} kg',
ha='center', va='bottom')

[Link](rotation=30, ha='right') # Rotar etiquetas del eje X si son largas

plt.tight_layout()
[Link]()

# Ejemplo con barras horizontales (barh)

fig_h, ax_h = [Link](figsize=(8,6))
ax_h.barh(frutas, ventas_kg, color=colores, edgecolor='black')
ax_h.set_title("Ventas de Frutas por Kilogramo (Horizontal)")
ax_h.set_xlabel("Ventas (kg)")
ax_h.set_ylabel("Tipo de Fruta")
ax_h.grid(axis='x', linestyle='--', alpha=0.7)
plt.tight_layout()
[Link]()
```

### 4. Gráfico de Torta (`[Link]()`)

* **Propósito:** Mostrar la proporción de cada categoría como parte de un todo.

Cada "porción" de la torta representa un porcentaje.
* **Cuándo Usarlo:**
* Mostrar la composición porcentual de algo (distribución de presupuesto,
cuota de mercado).
* Idealmente con pocas categorías (5-7 máximo), ya que demasiadas porciones
hacen el gráfico difícil de leer.
* ⚠️ **Advertencia:** Los gráficos de torta a menudo son criticados porque los
humanos no son muy buenos comparando ángulos visualmente. Un gráfico de barras
suele ser una mejor alternativa para comparaciones precisas. Úsalo con precaución y
para mostrar composiciones simples.
* **Función Clave:** `[Link](valores, labels=nombres_categorias, ...)`
* **Ejemplo:**
```python
import [Link] as plt

# Datos: Composición de un portafolio de inversión

activos = ['Acciones', 'Bonos', 'Inmobiliario', 'Efectivo']
porcentajes = [40, 30, 20, 10]
colores_pie = ['gold', 'lightskyblue', 'lightcoral', 'lightgreen']
explode_efectivo = (0, 0, 0, 0.1) # "Explotar" la 4ta porción (Efectivo)

fig, ax = [Link](figsize=(7,7))
[Link](porcentajes,
explode=explode_efectivo, # Desplaza una porción del centro
labels=activos,
colors=colores_pie,
autopct='%1.1f%%', # Formato para mostrar el porcentaje en cada
porción
shadow=True,
startangle=90, # Ángulo de inicio de la primera porción
wedgeprops={'edgecolor': 'black'}) # Propiedades de las cuñas

ax.set_title("Composición del Portafolio de Inversión")

[Link]('equal') # Asegura que el gráfico de torta sea circular, no una elipse.
[Link]()
```
* `autopct='%1.1f%%'`: Es una cadena de formato. `%1.1f` significa un
flotante con 1 decimal, y los `%%` literales muestran el símbolo '%'.

### 5. Histogramas (`[Link]()`)

* **Propósito:** Mostrar la distribución de frecuencia de una única variable

numérica continua. Agrupa los datos en "bins" (intervalos) y cuenta cuántas
observaciones caen en cada bin.
* **Cuándo Usarlo:**
* Entender la forma de la distribución de los datos (simétrica, sesgada,
unimodal, bimodal).
* Identificar el rango central de los datos y su dispersión.
* **Función Clave:** `[Link](datos, bins=numero_o_secuencia_de_bordes, ...)`
* **Ejemplo:**
```python
import [Link] as plt
import numpy as np

# Datos: Alturas de 1000 personas (distribución normal simulada)

[Link](101)
alturas = [Link](loc=170, scale=10, size=1000) # Media 170cm, Desv.
Est. 10cm

fig, ax = [Link](figsize=(8,6))
[Link](alturas,
bins=20, # Número de intervalos (bins)
color='skyblue',
edgecolor='black',
alpha=0.8)

ax.set_title("Histograma: Distribución de Alturas")

ax.set_xlabel("Altura (cm)")
ax.set_ylabel("Frecuencia (Número de Personas)")
[Link](axis='y', linestyle='--', alpha=0.7)

# Añadir una línea vertical para la media

media_alturas = [Link](alturas)
[Link](media_alturas, color='red', linestyle='dashed', linewidth=2,
label=f'Media: {media_alturas:.2f} cm')
[Link]()

[Link]()
```

Elegir el tipo de gráfico correcto es tan importante como crearlo correctamente.

Siempre considera qué historia quieres contar con tus datos y qué tipo de
visualización la transmitirá de la manera más clara y precisa.

💊 **Puntos Clave de Repaso:**

* **Línea (`plot`):** Tendencias en datos continuos/ordenados.
* **Dispersión (`scatter`):** Relación/correlación entre dos variables numéricas.
* **Barras (`bar`, `barh`):** Comparación de cantidades entre categorías
discretas.
* **Torta (`pie`):** Proporciones de un todo (usar con cautela).
* **Histograma (`hist`):** Distribución de frecuencia de una variable numérica.

---
## 🧩 Composiciones Gráficas: Múltiples Curvas y Múltiples Subplots

A menudo, necesitamos visualizar más de una serie de datos en el mismo gráfico o

presentar varios gráficos relacionados en una sola figura. Matplotlib maneja esto
con elegancia.

### 1. Múltiples Curvas en un Mismo `Axes`

Esto es lo más sencillo: simplemente llama al método de trazado (ej. `[Link]()`)

varias veces sobre el mismo objeto `Axes`. Cada llamada añadirá una nueva serie de
datos al mismo gráfico.

```python
import [Link] as plt
import numpy as np

x = [Link](0, 2 * [Link], 100)

y1 = [Link](x)
y2 = [Link](x)
y3 = [Link](x) * [Link](x)

fig, ax = [Link](figsize=(10, 6))

# Trazar múltiples curvas en el mismo ax

[Link](x, y1, label='Seno(x)', color='blue', linestyle='-')
[Link](x, y2, label='Coseno(x)', color='red', linestyle='--')
[Link](x, y3, label='Seno(x) * Coseno(x)', color='green', linestyle=':')

ax.set_title("Múltiples Funciones Trigonométricas")

ax.set_xlabel("X (radianes)")
ax.set_ylabel("Y")
[Link]() # Esencial aquí
[Link](True, alpha=0.5)
[Link](0, color='black', linewidth=0.5) # Línea de referencia en y=0

[Link]()
```
* **Clave:** Cada `[Link]()` añade una capa al `Axes` `ax`.
* **Importante:** Usar `label` en cada `plot` y luego `[Link]()` para que el
gráfico sea interpretable.
* **`figsize`:** Como se mencionó antes, `figsize=(width, height)` en
`[Link]()` controla el tamaño de la figura en pulgadas. Esto puede ser útil
para dar más espacio a múltiples curvas.

### 2. Grilla de Gráficos (Múltiples `Axes` en una `Figure`)

A veces, quieres mostrar varios gráficos relacionados uno al lado del otro o en una
disposición de grilla, pero cada uno como un gráfico independiente (su propio
`Axes`). Para esto, usamos los argumentos `nrows` y `ncols` en `[Link]()`.

```python
import [Link] as plt
import numpy as np

x = [Link](-5, 5, 100)
y_lin = x
y_cuad = x**2
y_cub = x**3
y_exp = [Link](x/2) # Escalar para que quepa mejor

# Crear una figura con una grilla de 2x2 subplots

# fig es la Figure completa
# axs es un array NumPy 2D de objetos Axes
fig, axs = [Link](nrows=2, ncols=2, figsize=(12, 10))

# Acceder a cada Axes individualmente usando indexación de array

# axs[fila, columna]

# Subplot 1: (fila 0, columna 0)

axs[0, 0].plot(x, y_lin, color='blue')
axs[0, 0].set_title('Función Lineal: $y=x$')
axs[0, 0].grid(True)

# Subplot 2: (fila 0, columna 1)

axs[0, 1].plot(x, y_cuad, color='red')
axs[0, 1].set_title('Función Cuadrática: $y=x^2$')
axs[0, 1].grid(True)

# Subplot 3: (fila 1, columna 0)

axs[0, 1].plot(x, y_cuad, color='red') # Corrección: Este era el mismo que el
anterior, vamos a cambiarlo
axs[1, 0].plot(x, y_cub, color='green')
axs[1, 0].set_title('Función Cúbica: $y=x^3$')
axs[1, 0].grid(True)

# Subplot 4: (fila 1, columna 1)

axs[1, 1].plot(x, y_exp, color='purple')
axs[1, 1].set_title('Función Exponencial: $y=e^{x/2}$')
axs[1, 1].grid(True)
axs[1, 1].set_ylim(-10, 50) # Ajustar límites para la exponencial

# Añadir un título general a toda la figura

[Link]("Comparación de Diferentes Funciones Matemáticas", fontsize=16,
fontweight='bold')

# Ajustar el espaciado entre subplots para evitar solapamientos

plt.tight_layout(rect=[0, 0, 1, 0.96]) # rect=[left, bottom, right, top] para dejar
espacio al suptitle

[Link]()
```

**Entendiendo `axs`:**
* Cuando `nrows=1` y `ncols=1` (por defecto), `[Link]()` devuelve un solo
objeto `Axes` en `ax`.
* Si `nrows > 1` o `ncols > 1`, `axs` se convierte en un array NumPy de objetos
`Axes`.
* Si `nrows=1` y `ncols=N` (una fila, N columnas), `axs` es un array 1D de
longitud N. Accedes con `axs[i]`.
```python
# fig, axs = [Link](1, 3) # Una fila, tres columnas
# axs[0].plot(...)
# axs[1].plot(...)
# axs[2].plot(...)
```
* Si `nrows=M` y `ncols=1` (M filas, una columna), `axs` es un array 1D de
longitud M. Accedes con `axs[i]`.
```python
# fig, axs = [Link](3, 1) # Tres filas, una columna
# axs[0].plot(...)
# axs[1].plot(...)
 # axs[2].plot(...)
```
* Si `nrows=M` y `ncols=N` (M filas, N columnas), `axs` es un array 2D de
forma (M, N). Accedes con `axs[fila, columna]`.

**Compartir Ejes (`sharex`, `sharey`):**

A veces, es útil que los subplots compartan el mismo eje X o Y (por ejemplo, si
todos muestran datos sobre el mismo rango de tiempo).
```python
# Todos los subplots compartirán el mismo eje X
fig, axs = [Link](2, 1, figsize=(8, 8), sharex=True)

axs[0].plot(x, y_cuad, color='red')

axs[0].set_title('Cuadrática')
axs[0].set_ylabel('Y Cuadrática')

axs[1].plot(x, y_cub, color='green')

axs[1].set_title('Cúbica')
axs[1].set_ylabel('Y Cúbica')
axs[1].set_xlabel('X (compartido)') # Solo necesitas poner la etiqueta X una vez

plt.tight_layout()
[Link]()
```
* Con `sharex=True`, los ticks y límites del eje X se sincronizan. Si haces zoom
en uno, los otros también se ajustan. Las etiquetas de los ticks del eje X solo
aparecerán en el subplot inferior.
* Similarmente, `sharey=True` comparte el eje Y.

**Ajustar Espaciado (`fig.subplots_adjust()` o `plt.tight_layout()`):**

Cuando tienes muchos subplots, títulos o etiquetas, pueden solaparse.
* `plt.tight_layout()`: Intenta ajustar automáticamente el espaciado para que
todo quepa. Es la opción más sencilla.
* `fig.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=None,
hspace=None)`: Ofrece control manual sobre los márgenes y el espacio entre subplots
(`wspace` para ancho, `hspace` para alto).

El material fuente menciona `fig.subplots_adjust(wspace=0.5, hspace=0.5)`. Esto

añade un espacio horizontal equivalente al 50% del ancho promedio de un axes, y un
espacio vertical equivalente al 50% del alto promedio de un axes, entre los
subplots.

Dominar estas técnicas de composición te permite crear dashboards visuales

complejos y comparaciones ricas de datos.

💊 **Puntos Clave de Repaso:**

* Para múltiples curvas en un `Axes`, simplemente llama a `[Link]()` (u otro
método de trazado) repetidamente sobre el mismo `ax`.
* Para una grilla de subplots, usa `fig, axs = [Link](nrows, ncols)`.
* Accede a `Axes` individuales en la grilla usando indexación de array en `axs`.
* `sharex=True` o `sharey=True` en `[Link]()` para sincronizar ejes entre
subplots.
* `plt.tight_layout()` o `fig.subplots_adjust()` para evitar solapamientos.

---
## Funciones de Gráficas: Abstracción y Reutilización para la Eficiencia

A medida que creas gráficos más complejos o necesitas generar visualizaciones

similares repetidamente, te encontrarás copiando y pegando mucho código. Este es un
signo clásico en programación de que es momento de **abstraer** la lógica común en
una **función**. Crear funciones para generar gráficos no solo hace tu código más
limpio y corto (principio DRY: Don't Repeat Yourself), sino también más fácil de
mantener y reutilizar.

**El Problema:**
Imagina que necesitas graficar tres funciones $x$, $x^2$, y $x^3$ en subplots
separados, cada uno con su propio título, etiquetas de ejes, leyenda y grilla. El
código para cada subplot sería muy similar, cambiando solo los datos `y`, el título
específico y quizás el color.

El material fuente muestra un ejemplo de esto, donde se repite la estructura:

```python
# ax[i].plot(...)
# ax[i].set_xlabel(...)
# ax[i].set_ylabel(...)
# ax[i].set_title(...)
# ax[i].legend()
# ax[i].grid()
```

**La Solución: Una Función de Graficación Genérica**

Podemos definir una función que tome los datos, el `Axes` donde graficar, y los
textos para etiquetas/títulos como parámetros.

```python
import [Link] as plt
import numpy as np

def crear_grafico_simple(ax, x_data, y_data, titulo, etiqueta_x, etiqueta_y,

color_linea, etiqueta_leyenda):
"""
Crea un gráfico de línea simple en un Axes dado con personalizaciones básicas.

Parámetros:
ax ([Link]): El Axes donde se dibujará el gráfico.
x_data (array-like): Datos para el eje X.
y_data (array-like): Datos para el eje Y.
titulo (str): Título del gráfico.
etiqueta_x (str): Etiqueta para el eje X.
etiqueta_y (str): Etiqueta para el eje Y.
color_linea (str): Color para la línea del gráfico.
etiqueta_leyenda (str): Etiqueta para la leyenda de esta línea.
"""
[Link](x_data, y_data, color=color_linea, label=etiqueta_leyenda)
ax.set_title(titulo, fontsize=12)
ax.set_xlabel(etiqueta_x, fontsize=10)
ax.set_ylabel(etiqueta_y, fontsize=10)
[Link]()
[Link](True, linestyle=':', alpha=0.7)

# Datos de ejemplo
x = [Link](-3, 3, 100)
y_funcs = {
"Lineal ($x$)": x,
"Cuadrática ($x^2$)": x**2,
"Cúbica ($x^3$)": x**3
}
colores = ['red', 'green', 'blue']

# Crear la figura y los subplots

num_funciones = len(y_funcs)
fig, axs = [Link](nrows=num_funciones, ncols=1, figsize=(6, 4 *
num_funciones), sharex=True)

# Usar la función para crear cada subplot

for i, (nombre_func, y_data_actual) in enumerate(y_funcs.items()):
# Si solo hay un subplot, axs no es un array, sino un solo Axes.
# Necesitamos manejar esto para que el código sea general.
current_ax = axs[i] if num_funciones > 1 else axs

crear_grafico_simple(ax=current_ax,
x_data=x,
y_data=y_data_actual,
titulo=f"Función {nombre_func}",
etiqueta_x="Eje X",
etiqueta_y="Eje Y",
color_linea=colores[i],
etiqueta_leyenda=nombre_func)

[Link]("Visualización de Múltiples Funciones con Función Reutilizable",

fontsize=16)
plt.tight_layout(rect=[0, 0, 1, 0.97])
[Link]()
```

**Ventajas de Usar Funciones para Graficar:**

1. **Reducción de Código:** Evita la repetición masiva.
2. **Consistencia:** Asegura que todos los gráficos generados por la función
tengan un estilo y estructura consistentes.
3. **Mantenibilidad:** Si necesitas cambiar algo (ej. el estilo de la grilla, el
tamaño de fuente del título) para todos los gráficos, solo lo cambias en un lugar:
dentro de la función.
4. **Legibilidad:** El código principal se vuelve más corto y fácil de entender,
ya que la complejidad de la creación del gráfico está encapsulada en la función.
5. **Reutilización:** Puedes usar la misma función en diferentes partes de tu
proyecto o incluso en otros proyectos.

**Consideraciones al Diseñar Funciones de Graficación:**

* **Parámetros:** Decide qué aspectos del gráfico deben ser personalizables a
través de parámetros de la función y cuáles pueden tener valores por defecto.
* **Flexibilidad:**
* ¿Debería la función siempre crear un nuevo `Axes` o tomar uno existente?
Tomar un `Axes` existente (como en el ejemplo) es más flexible, ya que permite
integrar el gráfico en disposiciones de subplots complejas.
* El material fuente tiene un ejemplo donde la función puede o no tomar un
`ax` (si `ax` es `None`, crea uno nuevo). Esto es una buena práctica para funciones
de utilidad.
* **Retorno:** ¿Debería la función devolver algo? Podría devolver el `Axes`
modificado, o quizás nada si opera por efecto secundario sobre el `Axes` pasado.

**Ejemplo del Material Fuente (Adaptado y Explicado):**

El material fuente propone una función `create_easy_graph` que tiene una lógica
para manejar el caso de un solo gráfico (donde `ax` podría ser `None`).

```python
def create_easy_graph_v2(x, y, label_leyenda, xlabel, ylabel, title, color=None,
ax=None):
"""
Crea un gráfico a partir de vectores x e y.
Si ax es None, crea una nueva figura y axes.
Si color es None, usa un color por defecto.
"""
if ax is None:
fig_local, ax_local = [Link](figsize=(7,5)) # Crea figura y axes
localmente
else:
ax_local = ax # Usa el axes provisto
fig_local = ax_local.figure # Obtiene la figura a la que pertenece el axes

if color is None:
color = "blue" # Color por defecto

ax_local.plot(x, y, label=label_leyenda, color=color)

ax_local.set_xlabel(xlabel)
ax_local.set_ylabel(ylabel)
ax_local.set_title(title)
ax_local.legend()
ax_local.grid(True, linestyle=':', alpha=0.6)

if ax is None: # Si se creó localmente, mostrarla es responsabilidad de la

función
[Link]() # O podríamos devolver fig_local, ax_local para más control
externo

return ax_local # Devolver el axes (modificado o creado)

# Ejemplo de uso para un solo gráfico

x_data = [Link](10)
y_data_single = x_data * 1.5
create_easy_graph_v2(x_data, y_data_single, "Mi Línea", "Entrada", "Salida",
"Gráfico Único con Función")

# Ejemplo de uso con subplots

fig_main, axs_main = [Link](1, 2, figsize=(12, 5))
y_data1 = [Link](x_data)
y_data2 = [Link](x_data)

create_easy_graph_v2(x_data, y_data1, "Seno", "X", "Y", "Subplot Seno",

color="magenta", ax=axs_main[0])
create_easy_graph_v2(x_data, y_data2, "Coseno", "X", "Y", "Subplot Coseno",
color="cyan", ax=axs_main[1])
fig_main.suptitle("Subplots con Función Reutilizable v2")
plt.tight_layout(rect=[0,0,1,0.95])
[Link]()
```
Esta `create_easy_graph_v2` es más versátil. La decisión de si `[Link]()` debe
estar dentro de la función o fuera depende del caso de uso. Generalmente, para
funciones de biblioteca, es mejor no llamar a `[Link]()` adentro, para dar más
control al código que la llama.

Este principio de crear funciones de ayuda es fundamental en el pensamiento

computacional y se aplica mucho más allá de la graficación.

💊 **Puntos Clave de Repaso:**

* Encapsular la lógica de graficación repetitiva en funciones mejora la calidad
del código.
* Las funciones deben ser diseñadas con parámetros adecuados para la
personalización necesaria.
* Considerar la flexibilidad: si la función debe crear sus propios
`Figure`/`Axes` o operar sobre unos existentes.

---
## 🔗 Integración con Pandas: Visualizando DataFrames Directamente

En el mundo real del análisis de datos, tus datos a menudo residirán en estructuras
de Pandas como `Series` y `DataFrames`. Matplotlib se integra de manera excelente
con Pandas, permitiéndote graficar tus datos con muy poco esfuerzo adicional.

**El Puente entre Pandas y Matplotlib:**

Pandas mismo tiene métodos de trazado incorporados (ej. `[Link]()`,
`[Link]()`) que, de hecho, **usan Matplotlib por debajo**. Estos métodos son
convenientes para gráficos rápidos directamente desde objetos Pandas. Sin embargo,
para un control más fino y para usar la API orientada a objetos de Matplotlib que
hemos estado aprendiendo (con `fig` y `ax`), simplemente pasas las columnas del
DataFrame (que son Series de Pandas) o arrays de NumPy derivados de ellas a las
funciones de Matplotlib como `[Link]()`, `[Link]()`, etc.

**Ejemplo del Material Fuente (Mascotas):**

El material fuente proporciona un DataFrame de ejemplo:
```python
import [Link] as plt
import pandas as pd
import numpy as np # Para el ejemplo de barras agrupadas

# Datos del DataFrame

data_mascotas = {
'animal': ['gato', 'serpiente', 'perro', 'gato', 'perro', 'serpiente', 'gato'],
'edad': [2.5, 3, 7, 1.5, 5, 2, 4.5],
'visitas': [1, 3, 2, 2, 1, 1, 3],
'prioridad': ['sí', 'sí', 'no', 'sí', 'no', 'sí', 'no']
}
df_mascotas = [Link](data_mascotas, index=['a', 'b', 'c', 'd', 'e', 'f',
'g'])

print("DataFrame de Mascotas:")
print(df_mascotas)
print("\n")

# 1. Gráfico de Barras: Edad de los animales

# Extraemos las columnas que queremos graficar
nombres_animales_unicos = df_mascotas['animal'].unique() # Podríamos querer agrupar
# Para un gráfico de barras simple de cada animal individual:
animal_labels = df_mascotas.index + " (" + df_mascotas['animal'] + ")" # Etiquetas
más descriptivas
edades = df_mascotas['edad']

fig1, ax1 = [Link](figsize=(10, 6))

[Link](animal_labels, edades, color=['skyblue', 'lightgreen', 'salmon', 'skyblue',
'salmon', 'lightgreen', 'skyblue'])
ax1.set_title('Edad de las Mascotas Individuales')
ax1.set_xlabel('Mascota (ID y Tipo)')
ax1.set_ylabel('Edad (años)')
[Link](rotation=45, ha="right")
plt.tight_layout()
[Link]()

# 2. Gráfico de Dispersión: Edad vs. Visitas

fig2, ax2 = [Link](figsize=(8, 6))
# Usar colores diferentes por tipo de animal para más información
colores_animal = {'gato': 'blue', 'serpiente': 'green', 'perro': 'red'}
colores_puntos = df_mascotas['animal'].map(colores_animal)

scatter = [Link](df_mascotas['edad'], df_mascotas['visitas'],

s=100, # Tamaño de los puntos
c=colores_puntos,
alpha=0.7,
edgecolors='black')
ax2.set_title('Edad vs. Número de Visitas al Veterinario')
ax2.set_xlabel('Edad (años)')
ax2.set_ylabel('Número de Visitas')
[Link](True, linestyle=':', alpha=0.5)

# Crear una leyenda manual para los colores

import [Link] as mpatches
legend_handles = [[Link](color=color, label=animal) for animal, color in
colores_animal.items()]
[Link](handles=legend_handles, title="Tipo de Animal")

[Link]()

# 3. Histograma: Distribución de Edades

fig3, ax3 = [Link](figsize=(8, 6))
[Link](df_mascotas['edad'], bins=5, color='purple', edgecolor='black',
alpha=0.75)
ax3.set_title('Distribución de Edades de las Mascotas')
ax3.set_xlabel('Edad (años)')
ax3.set_ylabel('Frecuencia')
[Link]()

# 4. Gráfico de Barras Agrupadas (un poco más avanzado, pero ilustrativo con
Pandas)
# Supongamos que queremos comparar edad promedio y visitas promedio por tipo de
animal
df_agrupado = df_mascotas.groupby('animal').mean()[['edad', 'visitas']]

n_grupos = len(df_agrupado)
index_barras = [Link](n_grupos)
ancho_barra = 0.35

fig4, ax4 = [Link](figsize=(10,7))

barras_edad = [Link](index_barras - ancho_barra/2, df_agrupado['edad'],
ancho_barra, label='Edad Promedio', color='coral')
barras_visitas = [Link](index_barras + ancho_barra/2, df_agrupado['visitas'],
ancho_barra, label='Visitas Promedio', color='lightblue')

ax4.set_xlabel('Tipo de Animal')
ax4.set_ylabel('Valor Promedio')
ax4.set_title('Comparación de Edad y Visitas Promedio por Tipo de Animal')
ax4.set_xticks(index_barras)
ax4.set_xticklabels(df_agrupado.index)
[Link]()
[Link](axis='y', linestyle='--', alpha=0.6)
plt.tight_layout()
[Link]()
```

**Claves al Trabajar con Pandas y Matplotlib:**

* **Selección de Datos:** Usa la indexación de Pandas (`df['columna']`,
`[Link][]`, `[Link][]`) para seleccionar las `Series` o los arrays de NumPy que
necesitas para tus ejes `x` e `y`.
* **Datos Categóricos:** Para gráficos de barras o de torta, a menudo usarás
`df['columna_categorica'].value_counts()` para obtener las frecuencias, o
`[Link]('columna_categorica').sum()` (o `.mean()`, etc.) para agregar datos
antes de graficar.
* **Índices:** El índice de un DataFrame o Serie de Pandas a menudo puede usarse
directamente como etiquetas para el eje X en gráficos de barras o líneas.
* **Métodos `.plot` de Pandas:**
* Pandas ofrece una API de trazado conveniente: `[Link](kind='bar')`,
`df['columna'].hist()`, etc.
* Estos son útiles para exploración rápida. Por ejemplo:
```python
# Gráfico de barras rápido de las edades usando el plot de Pandas
df_mascotas['edad'].plot(kind='bar', title='Edades (Pandas Plot)',
figsize=(8,5), color='teal')
[Link]("Edad (años)")
[Link](ticks=range(len(df_mascotas)), labels=animal_labels,
rotation=45, ha="right")
plt.tight_layout()
[Link]()
```
* Para obtener un objeto `Axes` de Matplotlib desde un plot de Pandas y
personalizarlo más:
```python
ax_pandas = df_mascotas.plot(x='edad', y='visitas', kind='scatter',
title='Scatter (Pandas Plot)', figsize=(8,6))
ax_pandas.set_xlabel("Edad (años) - Personalizado")
ax_pandas.grid(True)
[Link]()
```
* La elección entre usar los métodos `.plot` de Pandas o pasar datos a
`[Link]()` de Matplotlib depende del nivel de control que necesites. Para
personalizaciones complejas o subplots múltiples, la API de Matplotlib es
generalmente más flexible.

La integración fluida entre Pandas para la manipulación de datos y Matplotlib para

la visualización es una de las piedras angulares del ecosistema de ciencia de datos
en Python.

💊 **Puntos Clave de Repaso:**

* Puedes pasar columnas de DataFrames de Pandas (que son `Series`) directamente a
las funciones de trazado de Matplotlib.
* Pandas tiene sus propios métodos `.plot()` que usan Matplotlib internamente
para gráficos rápidos.
* Para un control total, extrae los datos de Pandas y usa la API orientada a
objetos de Matplotlib (`fig`, `ax`).

---
## 🏁 Síntesis de Excelencia: El Poder Transformador de la Visualización

Hemos recorrido un camino significativo, desde los fundamentos conceptuales de

Matplotlib hasta la creación de una variedad de gráficos personalizados y
composiciones complejas. Más allá de la sintaxis y los comandos, el objetivo ha
sido cultivar una comprensión del **por qué** y el **cómo** de la visualización de
datos efectiva.

**Principios Fundamentales Reforzados:**

1. **La Jerarquía de Matplotlib (`Figure`, `Axes`, `Axis`):** Entender esta
estructura es clave para el control y la flexibilidad. La `Figure` es el lienzo;
los `Axes` son los gráficos individuales dentro de ese lienzo.
2. **El Paradigma Orientado a Objetos:** Trabajar explícitamente con objetos `fig`
y `ax` (obtenidos a través de `[Link]()`) es la práctica recomendada para la
claridad, el control y la escalabilidad, especialmente para gráficos no triviales.
3. **El Flujo de Trabajo Sistemático:** Preparar datos $\rightarrow$ Crear
`Figure`/`Axes` $\rightarrow$ Trazar $\rightarrow$ Personalizar $\rightarrow$
Mostrar/Guardar. Este proceso es aplicable a casi cualquier tarea de visualización.
4. **La Personalización es Poder:** Matplotlib permite un control granular sobre
casi todos los aspectos de un gráfico. Títulos, etiquetas, leyendas, colores,
estilos, grillas y ticks no son meros adornos; son cruciales para la claridad y la
interpretación.
5. **Elegir el Gráfico Adecuado:** El tipo de gráfico (línea, dispersión, barras,
torta, histograma, etc.) debe corresponder al tipo de datos y a la historia que se
quiere contar. No hay un "mejor" gráfico universal; la elección depende del
contexto.
6. **Abstracción y Reutilización:** Crear funciones para generar gráficos comunes
es una práctica de buen diseño de software que ahorra tiempo, reduce errores y
mejora la consistencia.
7. **Integración con el Ecosistema:** Matplotlib se integra naturalmente con NumPy
y Pandas, herramientas estándar para el manejo de datos en Python.

**Más Allá de Estos Apuntes:**

Matplotlib es una biblioteca vasta. Lo que hemos cubierto son los fundamentos
esenciales y las técnicas más comunes. Hay mucho más por explorar:
* Gráficos 3D.
* Gráficos animados e interactivos.
* Personalización avanzada de estilos (stylesheets).
* Integración con interfaces gráficas de usuario (GUIs).
* Bibliotecas construidas sobre Matplotlib que simplifican ciertos tipos de
gráficos (ej. Seaborn para gráficos estadísticos).

**La Visualización como Habilidad Esencial:**

En la era del Big Data y la ciencia de datos, la capacidad de visualizar
información de manera efectiva ya no es un lujo, sino una necesidad. Un buen
gráfico puede:
* Revelar patrones ocultos que los números por sí solos no muestran.
* Comunicar hallazgos complejos de manera intuitiva.
* Persuadir e informar decisiones.
* Fomentar la curiosidad y la exploración adicional.

Te animamos a practicar, experimentar y, lo más importante, a pensar críticamente

sobre cómo tus visualizaciones pueden iluminar los datos y contar historias
convincentes. El dominio de Matplotlib es una inversión valiosa en tu capacidad
para entender y comunicar el mundo a través de los datos.

---
## 📖 Glosario Detallado y Contextualizado

* **`Figure` (Figura):**
* **Definición:** El contenedor de más alto nivel en Matplotlib para todos
los elementos de un gráfico (lienzo completo). Puede contener múltiples `Axes`.
* **Importancia:** Gestiona propiedades globales como el tamaño, y es el
objeto que se guarda en un archivo.
 * **Notación:** Objeto de tipo `[Link]`, comúnmente
asignado a la variable `fig`.

* **`Axes` (Subgráfico/Área de Trazado):**

* **Definición:** La región dentro de una `Figure` donde se trazan los datos
y se define un sistema de coordenadas. Es lo que comúnmente se considera "un
gráfico".
* **Importancia:** La mayoría de las funciones de trazado (`plot`, `scatter`,
`bar`, etc.) son métodos de un objeto `Axes`.
* **Notación:** Objeto de tipo `[Link]`, comúnmente asignado a
`ax` (para un solo Axes) o `axs` (para un array de Axes).
* ⚠️ **Distinción Clave:** `Axes` (con 'e', se refiere al área de trazado)
vs. `Axis` (sin 'e', se refiere a un eje dimensional como X o Y).

* **`Axis` (Eje):**
* **Definición:** Objeto que controla los límites de los datos, las marcas
(ticks) y las etiquetas de un eje dimensional (X, Y, o Z).
* **Importancia:** Permite la personalización detallada de la escala y
apariencia de cada eje.
* **Notación:** `[Link]`, `[Link]` son instancias de `Axis`.

* **`pyplot`:**
* **Definición:** Un módulo de Matplotlib (`[Link]`) que
proporciona una interfaz de scripting similar a MATLAB para crear gráficos.
* **Importancia:** Ofrece una forma rápida de generar gráficos simples y
gestiona un "estado actual" implícito (figura y axes actuales).
* **Contexto:** Aunque útil, para control y complejidad se prefiere la API
orientada a objetos. Comúnmente importado como `import [Link] as plt`.

* **API Orientada a Objetos (OO):**

* **Definición:** Enfoque de Matplotlib donde se crean y manipulan
explícitamente objetos `Figure` y `Axes`.
* **Importancia:** Proporciona mayor control, claridad y es preferible para
gráficos complejos o integración en aplicaciones.

* **`[Link]()`:**
* **Definición:** Función de conveniencia en `pyplot` que crea una `Figure` y
un conjunto de `Axes` (subgráficos) simultáneamente.
* **Importancia:** Es la forma recomendada de iniciar un gráfico usando la
API OO. Devuelve `fig, ax` o `fig, axs`.

* **`[Link](x, y, ...)`:**
* **Definición:** Método de un objeto `Axes` para crear gráficos de línea.
* **Importancia:** Fundamental para visualizar tendencias en datos continuos.
Acepta numerosos parámetros de personalización.

* **`[Link](x, y, ...)`:**
* **Definición:** Método de un objeto `Axes` para crear gráficos de
dispersión (puntos).
* **Importancia:** Útil para mostrar relaciones entre dos variables numéricas
y puede personalizar cada punto individualmente.

* **`[Link](categorias, valores, ...)` / `[Link](...)`:**

* **Definición:** Métodos de un objeto `Axes` para crear gráficos de barras
(verticales u horizontales).
* **Importancia:** Comparan cantidades entre categorías discretas.

* **`[Link](valores, labels=..., autopct=...)`:**

* **Definición:** Método de un objeto `Axes` para crear gráficos de torta.
 * **Importancia:** Muestra proporciones de un todo. Usar con cautela.
* **`autopct`:** Parámetro para formatear y mostrar porcentajes en las
porciones.

* **`[Link](datos, bins=...)`:**
* **Definición:** Método de un objeto `Axes` para crear histogramas.
* **Importancia:** Visualiza la distribución de frecuencia de una variable
numérica.
* **`bins`:** Número de intervalos o secuencia de bordes de los intervalos.

* **Título (`ax.set_title("...")`):**
* **Definición:** Texto descriptivo en la parte superior de un `Axes`.

* **Etiquetas de Ejes (`ax.set_xlabel("...")`, `ax.set_ylabel("...")`):**

* **Definición:** Texto que describe qué representan los ejes X e Y.

* **Leyenda (`[Link]()`):**
* **Definición:** Un recuadro que explica el significado de diferentes
líneas, colores o símbolos en un gráfico. Se activa usando el argumento `label` en
las funciones de trazado.

* **Grilla/Cuadrícula (`[Link](True)`):**
* **Definición:** Líneas de fondo que ayudan a leer los valores del gráfico.

* **Ticks (`ax.set_xticks([...])`, `ax.set_yticks([...])`):**

* **Definición:** Las marcas (pequeñas líneas) en los ejes que indican puntos
específicos.
* **`Tick Labels` (`ax.set_xticklabels([...])`):** Las etiquetas de texto
asociadas a los ticks.

* **Límites de Ejes (`ax.set_xlim((min, max))`, `ax.set_ylim((min, max))`):**

* **Definición:** Establecen el rango mínimo y máximo visible para cada eje.

* **`figsize`:**
* **Definición:** Parámetro (generalmente en `[Link](figsize=(ancho,
alto))`) que especifica el tamaño de la `Figure` en pulgadas.

* **`[Link]()`:**
* **Definición:** Función de `pyplot` que muestra todas las figuras activas.

* **`[Link]("[Link]")`:**
* **Definición:** Método de un objeto `Figure` para guardar el gráfico en un
archivo.

---
## Mapa Conceptual Sugerido

Un mapa conceptual para Matplotlib podría estructurarse de la siguiente manera:

1. **Nodo Central:** **Matplotlib**

* **Conectado a:** "Visualización de Datos en Python" (Propósito)

2. **Principales Componentes (Jerarquía):**

* **`Figure` (Lienzo Global)**
* Relacionado con: `figsize`, `[Link]()`, `[Link]()`
* Contiene: **`Axes` (Subgráfico/Área de Trazado)** (Relación: "puede
contener uno o más")
* **`Axes`**
* Relacionado con: `[Link]()`, `[Link]()`, `[Link]()`, `[Link]()`,
`[Link]()`, `ax.set_title()`, `ax.set_xlabel()`, `ax.set_ylabel()`, `[Link]()`,
`[Link]()`, `ax.set_xlim()`, `ax.set_ylim()`, `ax.set_xticks()`, `ax.set_yticks()`
* Contiene: **`X-Axis`**, **`Y-Axis`** (Relación: "gestiona")
* **`Axis` (X-Axis, Y-Axis)**
* Relacionado con: Ticks, Tick Labels, Axis Label, Escala

3. **Flujo de Trabajo Común:**

* "Preparar Datos (Listas, NumPy arrays, Pandas Series/DataFrames)"
* Lleva a: "`import [Link] as plt`"
* Lleva a: "`fig, ax = [Link]()`" (Creación de Figura/Axes)
* Lleva a: "Métodos de Trazado de `ax` (ej. `[Link]()`)"
* Lleva a: "Métodos de Personalización de `ax` (ej.
`ax.set_title()`)"
* Lleva a: "`[Link]()` o `[Link]()`"
(Visualización/Guardado)

4. **Tipos de Gráficos (conectados a `Axes` como métodos):**

* `[Link]()` $\rightarrow$ "Gráfico de Línea" $\rightarrow$ Usado para:
"Tendencias, Datos Continuos"
* `[Link]()` $\rightarrow$ "Gráfico de Dispersión" $\rightarrow$ Usado
para: "Correlaciones, Clusters"
* `[Link]()` / `[Link]()` $\rightarrow$ "Gráfico de Barras" $\rightarrow$
Usado para: "Comparar Categorías Discretas"
* `[Link]()` $\rightarrow$ "Gráfico de Torta" $\rightarrow$ Usado para:
"Proporciones de un Todo"
* `[Link]()` $\rightarrow$ "Histograma" $\rightarrow$ Usado para:
"Distribución de Frecuencia"

5. **Conceptos de Composición:**
* "Múltiples Curvas en un `Axes`" (Relacionado con: múltiples llamadas a
`[Link]()` en el mismo `ax`, `[Link]()`)
* "Grilla de Subplots (`[Link](nrows, ncols)`) "
* Relacionado con: `axs` (array de Axes), indexación (`axs[i]`,
`axs[i,j]`), `sharex`/`sharey`, `plt.tight_layout()`

6. **Principios de Diseño de Software Aplicados:**

* "Funciones de Graficación Reutilizables"
* Relacionado con: "Abstracción", "DRY (Don't Repeat Yourself)"

7. **Integración con Ecosistema:**

* "Pandas DataFrames" $\rightarrow$ "Selección de Columnas/Series" $\
rightarrow$ Entrada para "Métodos de Trazado de `ax`"
* "NumPy Arrays" $\rightarrow$ Entrada para "Métodos de Trazado de `ax`"

Este mapa conceptual ayudaría a visualizar las interrelaciones entre los diferentes
conceptos y herramientas dentro de Matplotlib, proporcionando una visión general
estructurada del tema.

---
## 📝 Preguntas Conceptuales de Comprensión y 💭 Preguntas de Reflexión

Estas preguntas están diseñadas para solidificar tu comprensión de los conceptos

clave y fomentar un pensamiento más profundo sobre la visualización de datos.

**Preguntas Conceptuales:**

1. **Jerarquía:** Describe con tus propias palabras la relación entre una

`Figure`, un `Axes` y un `Axis` en Matplotlib. ¿Por qué es útil esta jerarquía?
2. **`pyplot` vs. API OO:** ¿Cuáles son las principales diferencias entre usar la
interfaz de `pyplot` (estilo MATLAB) y la interfaz orientada a objetos (API OO) en
Matplotlib? ¿En qué escenarios preferirías una sobre la otra y por qué?
3. **`[Link]()`:** ¿Qué devuelve la función `[Link]()`? ¿Cómo cambia
lo que devuelve si pasas los argumentos `nrows=2, ncols=3`?
4. **Personalización:** ¿Por qué es importante personalizar un gráfico más allá de
simplemente trazar los datos? Menciona al menos cinco elementos de un gráfico que
se pueden personalizar y el método de `Axes` asociado para hacerlo.
5. **Leyendas:** ¿En qué situación es indispensable una leyenda en un gráfico?
¿Cuáles son los dos pasos principales para añadir una leyenda funcional a un
gráfico con múltiples líneas?
6. **Elección del Gráfico:**
* Si quisieras mostrar la tendencia del precio de una acción a lo largo de un
año, ¿qué tipo de gráfico usarías y por qué?
* Si quisieras comparar las ventas totales de cinco productos diferentes en
el último trimestre, ¿qué tipo de gráfico sería más apropiado y por qué?
* Si tuvieras datos de altura y peso de 100 personas y quisieras investigar
si hay una relación entre ambas, ¿qué gráfico elegirías?
7. **Funciones de Graficación:** ¿Cuáles son los beneficios de crear funciones
personalizadas para generar gráficos en Matplotlib, en lugar de escribir el código
completo cada vez?

**Preguntas de Reflexión:**

1. **"Una imagen vale más que mil palabras":** ¿Cómo se aplica este dicho al
contexto de la visualización de datos? ¿Puedes pensar en un ejemplo donde un
gráfico podría revelar algo que sería muy difícil de comunicar solo con números o
texto?
2. **Ética en la Visualización:** ¿De qué maneras podría un gráfico ser engañoso o
manipular la percepción del espectador, incluso si los datos subyacentes son
correctos? (Piensa en escalas de ejes, elección de colores, tipo de gráfico, etc.)
¿Qué responsabilidad tiene el creador del gráfico?
3. **Simplicidad vs. Información:** ¿Cómo equilibras la necesidad de incluir
suficiente información en un gráfico para que sea útil, con el riesgo de hacerlo
demasiado complejo o "ruidoso" (chart junk)?
4. **Más Allá de lo Básico:** Si tuvieras que visualizar una relación entre *tres*
variables numéricas simultáneamente, ¿qué estrategias o tipos de gráficos (quizás
no cubiertos en detalle aquí) podrías considerar?
5. **Audiencia:** ¿Cómo podría cambiar el diseño de tu visualización (tipo de
gráfico, nivel de detalle, anotaciones) dependiendo de si tu audiencia son expertos
técnicos, directivos de una empresa o el público general?

---
## 🧪 Problemas de Diseño/Programación y 🔍 Ejercicios de Análisis

Estos ejercicios te ayudarán a aplicar lo aprendido y a pensar como un creador de

visualizaciones.

**Problemas de Diseño/Programación:**

1. **Crecimiento de Plantas:**
* **Datos:**
* Semanas: `[1, 2, 3, 4, 5, 6, 7, 8]`
* Altura Planta A (cm): `[2.5, 3.1, 3.9, 4.5, 5.3, 5.9, 6.4, 7.0]`
* Altura Planta B (cm, con diferente fertilizante): `[2.2, 2.8, 3.8, 4.8,
6.0, 7.1, 8.0, 9.1]`
* **Tarea:** Crea un gráfico de líneas que muestre el crecimiento de ambas
plantas en el mismo `Axes`.
* La Planta A debe ser una línea azul continua con marcadores circulares.
* La Planta B debe ser una línea verde discontinua con marcadores
triangulares.
* Incluye un título apropiado, etiquetas para los ejes X e Y, y una
leyenda.
* Añade una grilla.
* Establece el límite del eje Y de 0 a 10 cm.

2. **Resultados de Encuesta de Satisfacción:**

* **Datos:**
* Categorías de Satisfacción: `['Muy Insatisfecho', 'Insatisfecho',
'Neutral', 'Satisfecho', 'Muy Satisfecho']`
* Número de Respuestas: `[15, 30, 55, 120, 80]`
* **Tarea:** Crea un gráfico de barras horizontales que muestre el número de
respuestas para cada categoría de satisfacción.
* Cada barra debe tener un color diferente (tú eliges).
* Añade un título, y etiquetas para los ejes.
* Muestra el valor numérico de respuestas al final de cada barra.

3. **Dashboard de Ventas Trimestrales:**

* **Datos:**
* Trimestres: `['Q1', 'Q2', 'Q3', 'Q4']`
* Ventas Producto X ($ miles): `[120, 150, 130, 180]`
* Ventas Producto Y ($ miles): `[80, 90, 110, 100]`
* Cuota de Mercado Total (Producto X vs Y en Q4): X=64%, Y=36%
* **Tarea:** Crea una figura (`figsize=(12,5)`) con dos subplots uno al lado
del otro:
* **Subplot 1 (Izquierda):** Un gráfico de líneas comparando las ventas
trimestrales del Producto X y el Producto Y. Usa diferentes colores y estilos.
Incluye leyenda, título y etiquetas.
* **Subplot 2 (Derecha):** Un gráfico de torta mostrando la cuota de
mercado del Producto X vs. el Producto Y en el Q4. Muestra porcentajes y un título.
* Añade un título general a toda la figura (`[Link]()`).

**Ejercicios de Análisis y Depuración:**

1. **Predecir el Gráfico:**
Dado el siguiente código, describe verbalmente o dibuja esquemáticamente cómo
se verá el gráfico resultante. Presta atención a los datos, tipos de trazado y
personalizaciones.
```python
import [Link] as plt
import numpy as np
x = [Link]([1, 2, 3, 4, 5])
y1 = x * 2
y2 = x**2
fig, ax = [Link]()
[Link](x, y1, color='magenta', linestyle=':', marker='s', label='Lineal')
[Link](x + 0.1, y2, color='cyan', width=0.4, label='Cuadrático') # Pequeño
offset en x para barras
ax.set_xlabel("Entrada")
ax.set_title("Comparación Mixta")
[Link](loc='upper left')
# [Link]() # Imagina que se llama
```

2. **Encontrar el Error:**
El siguiente código intenta crear un gráfico de dispersión, pero tiene un error
que impide que se ejecute o que produzca el resultado esperado. Identifica el error
y explica cómo lo corregirías.
```python
 import [Link] as plt
datos_x = [10, 12, 15, 17, 20, 22]
datos_y = [5, 7, 6, 8, 7] # ¡Atención aquí!
fig, ax = [Link]()
[Link](datos_x, datos_y)
ax.set_title("Mi Scatter Plot con Problemas")
# [Link]()
```

3. **Mejorar el Gráfico:**
El siguiente código produce un gráfico funcional, pero es poco informativo y
difícil de leer. Sugiere al menos tres mejoras específicas (con el código para
implementarlas) que harían este gráfico mucho mejor.
```python
import [Link] as plt
meses = range(1, 13)
producto_a_ventas = [10,12,15,14,18,20,22,21,19,17,14,12]
producto_b_ventas = [8,9,11,10,12,14,15,14,13,11,10,9]
fig, ax = [Link]()
[Link](meses, producto_a_ventas)
[Link](meses, producto_b_ventas)
# [Link]()
```

---