Formación corporativa en Pandas

Pandas proporciona dos estructuras de datos fundamentales para el análisis y manipulación de información: las Series y los DataFrames. Estas estructuras están optimizadas para trabajar con datos tabulares y series temporales, ofreciendo una combinación de eficiencia y flexibilidad.

La biblioteca Pandas está construida sobre NumPy, beneficiándose de su velocidad y rendimiento. Sin embargo, Pandas añade capacidades adicionales específicamente diseñadas para el trabajo con datos estructurados y etiquetados.

En este módulo, exploraremos en profundidad las características, métodos y operaciones posibles con Series y DataFrames, que son los componentes esenciales de cualquier análisis de datos con Python.

Series en Pandas

Definición y características de Series

Una Serie en Pandas es una estructura unidimensional similar a un array o una lista, pero con funcionalidades adicionales. Podemos considerarla como una columna única de datos etiquetados.

Las Series tienen dos componentes principales:

• Valores: los datos almacenados (array de NumPy)
• Índice: etiquetas para cada elemento (pueden ser números, fechas, cadenas, etc.)

Esta combinación de valores e índices hace que las Series sean extremadamente versátiles para representar diferentes tipos de datos secuenciales.

Creación de Series

Existen varias formas de crear una Serie en Pandas. Veamos las más comunes:

1. A partir de una lista:

import pandas as pd

## Crear una Serie a partir de una lista
numeros = pd.Series([10, 20, 30, 40, 50])
print(numeros)

2. A partir de un array de NumPy:

import numpy as np
import pandas as pd

## Crear una Serie a partir de un array de NumPy
array = np.array([1, 2, 3, 4, 5])
serie_numpy = pd.Series(array)
print(serie_numpy)

3. A partir de un diccionario:

## Crear una Serie a partir de un diccionario
diccionario = {'a': 10, 'b': 20, 'c': 30}
serie_dict = pd.Series(diccionario)
print(serie_dict)

4. Especificando un índice personalizado:

## Crear una Serie con índice personalizado
serie_indice = pd.Series([100, 200, 300, 400], index=['w', 'x', 'y', 'z'])
print(serie_indice)

Acceso a elementos de Series

El acceso a los elementos de una Serie se puede realizar de varias maneras:

1. Por posición (similar a una lista):

serie = pd.Series([10, 20, 30, 40], index=['a', 'b', 'c', 'd'])

## Acceso por posición
print(serie[0])  # Devuelve 10

2. Por etiqueta (usando el índice):

## Acceso por etiqueta
print(serie['a'])  # Devuelve 10

3. Por condiciones (filtrado):

## Filtrado de elementos
print(serie[serie > 20])  # Devuelve solo los elementos mayores que 20

4. Utilizando métodos loc e iloc:

## Usando loc (acceso por etiqueta)
print(serie.loc['b'])  # Devuelve 20

## Usando iloc (acceso por posición)
print(serie.iloc[1])  # Devuelve 20

Operaciones con Series

Las Series permiten realizar operaciones matemáticas y estadísticas de forma sencilla:

1. Operaciones aritméticas:

serie1 = pd.Series([1, 2, 3, 4])
serie2 = pd.Series([10, 20, 30, 40])

## Suma
print(serie1 + serie2)

## Multiplicación
print(serie1 * 2)

2. Operaciones estadísticas:

serie = pd.Series([10, 20, 30, 40, 50])

## Estadísticas básicas
print("Media:", serie.mean())
print("Máximo:", serie.max())
print("Mínimo:", serie.min())
print("Desviación estándar:", serie.std())

3. Aplicación de funciones:

## Aplicar una función a cada elemento
resultado = serie.apply(lambda x: x**2)
print(resultado)

Métodos importantes de Series

Las Series tienen numerosos métodos útiles para el análisis de datos:

1. value_counts(): Cuenta la frecuencia de aparición de cada valor

colores = pd.Series(['rojo', 'azul', 'verde', 'rojo', 'verde', 'azul', 'rojo'])
print(colores.value_counts())

2. unique(): Devuelve los valores únicos en la Serie

print(colores.unique())

3. isnull(): Detecta valores nulos

serie_con_nulos = pd.Series([1, 2, None, 4, np.nan])
print(serie_con_nulos.isnull())

4. dropna(): Elimina valores nulos

print(serie_con_nulos.dropna())

5. fillna(): Rellena valores nulos

print(serie_con_nulos.fillna(0))

Casos de uso comunes de Series

Las Series son ideales para:

• Series temporales: Representar datos que evolucionan con el tiempo
• Vectores estadísticos: Cálculos y análisis sobre una única variable
• Columnas de datos: Trabajar con una única dimensión antes de incorporarla a un DataFrame
• Mapeo de valores: Usar Series como diccionarios optimizados para operaciones vectorizadas

DataFrames en Pandas

Definición y características de DataFrames

Un DataFrame es una estructura de datos bidimensional, similar a una tabla de base de datos relacional o una hoja de cálculo. Es la estructura de datos más importante en Pandas.

Los componentes principales de un DataFrame son:

• Columnas: Series etiquetadas con diferentes tipos de datos
• Filas: Registros individuales con valores para cada columna
• Índice: Etiquetas para cada fila
• Valores: Los datos almacenados (matriz 2D de NumPy)

Los DataFrames están optimizados para ofrecer un rendimiento excepcional en operaciones de análisis de datos y manipulación de tablas grandes.

Creación de DataFrames

Existen diversas formas de crear un DataFrame:

1. A partir de un diccionario de listas:

import pandas as pd

## Diccionario de listas
datos = {
    'Nombre': ['Ana', 'Juan', 'María', 'Carlos'],
    'Edad': [25, 30, 22, 28],
    'Ciudad': ['Madrid', 'Barcelona', 'Sevilla', 'Valencia']
}

df = pd.DataFrame(datos)
print(df)

2. A partir de una lista de diccionarios:

## Lista de diccionarios
personas = [
    {'Nombre': 'Ana', 'Edad': 25, 'Ciudad': 'Madrid'},
    {'Nombre': 'Juan', 'Edad': 30, 'Ciudad': 'Barcelona'},
    {'Nombre': 'María', 'Edad': 22, 'Ciudad': 'Sevilla'}
]

df2 = pd.DataFrame(personas)
print(df2)

3. A partir de un array de NumPy:

import numpy as np

## Array de NumPy
array_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
df3 = pd.DataFrame(array_2d, columns=['A', 'B', 'C'])
print(df3)

4. A partir de archivos externos:

## Desde un archivo CSV
## df4 = pd.read_csv('datos.csv')

## Desde un archivo Excel
## df5 = pd.read_excel('datos.xlsx')

Estructura de un DataFrame

La estructura de un DataFrame puede analizarse mediante varios atributos:

df = pd.DataFrame({
    'A': [1, 2, 3],
    'B': ['a', 'b', 'c'],
    'C': [True, False, True]
})

## Forma (filas, columnas)
print("Forma:", df.shape)

## Dimensiones
print("Dimensiones:", df.ndim)

## Tamaño (número total de elementos)
print("Tamaño:", df.size)

## Tipos de datos
print("Tipos de datos:\n", df.dtypes)

## Información general
print("Información:\n")
df.info()

Selección y acceso a datos en DataFrames

El acceso a los datos en un DataFrame se puede realizar de varias formas:

1. Selección de columnas:

## Seleccionar una columna (devuelve una Serie)
print(df['A'])

## Seleccionar múltiples columnas (devuelve un DataFrame)
print(df[['A', 'B']])

2. Selección de filas por posición con iloc:

## Seleccionar una fila por posición
print(df.iloc[0])

## Seleccionar múltiples filas
print(df.iloc[0:2])

## Seleccionar filas y columnas específicas
print(df.iloc[0:2, 0:2])

3. Selección de filas por etiqueta con loc:

## DataFrame con índices personalizados
df_indice = pd.DataFrame(
    {'A': [1, 2, 3], 'B': [4, 5, 6]},
    index=['fila1', 'fila2', 'fila3']
)

## Seleccionar por etiqueta
print(df_indice.loc['fila1'])

## Seleccionar múltiples filas por etiqueta
print(df_indice.loc[['fila1', 'fila3']])

4. Filtrado condicional:

## Filtrar filas según una condición
df_numeros = pd.DataFrame({'A': [10, 20, 30, 40], 'B': [5, 10, 15, 20]})
filtro = df_numeros['A'] > 20
print(df_numeros[filtro])

## Filtros combinados
print(df_numeros[(df_numeros['A'] > 20) & (df_numeros['B'] <= 15)])

Atributos importantes de los DataFrames

Los DataFrames cuentan con varios atributos útiles:

1. columns: Devuelve las etiquetas de las columnas

print(df.columns)

2. index: Devuelve el índice de filas

print(df.index)

3. values: Devuelve los datos como un array de NumPy

print(df.values)

4. T: Transpone el DataFrame (intercambia filas por columnas)

print(df.T)

5. axes: Devuelve una lista con los ejes (filas y columnas)

print(df.axes)

Métodos principales de DataFrames

Los DataFrames ofrecen numerosos métodos para manipular datos:

1. head() y tail(): Muestran las primeras o últimas filas

## Primeras 2 filas
print(df.head(2))

## Últimas 2 filas
print(df.tail(2))

2. describe(): Proporciona estadísticas descriptivas

df_nums = pd.DataFrame({'A': [1, 2, 3, 4, 5], 'B': [10, 20, 30, 40, 50]})
print(df_nums.describe())

3. sort_values(): Ordena por valores

## Ordenar por una columna
print(df_nums.sort_values(by='B', ascending=False))

4. drop(): Elimina filas o columnas

## Eliminar una columna
print(df.drop('A', axis=1))

## Eliminar una fila
print(df.drop(0, axis=0))

5. groupby(): Agrupa datos y permite operaciones por grupo

df_ventas = pd.DataFrame({
    'Producto': ['A', 'B', 'A', 'C', 'B', 'A'],
    'Ventas': [100, 200, 150, 300, 250, 180]
})

## Agrupar por producto y sumar ventas
print(df_ventas.groupby('Producto').sum())

Casos de uso típicos de DataFrames

Los DataFrames son especialmente útiles para:

• Análisis exploratorio de conjuntos de datos
• Limpieza y transformación de

La manipulación de datos constituye una fase esencial en cualquier proyecto de análisis. Los científicos de datos dedican entre el 50% y el 80% de su tiempo a preparar, transformar y reorganizar datos antes de poder extraer conocimiento valioso.

Pandas proporciona un ecosistema completo de herramientas que permiten realizar estas operaciones de manera eficiente, convirtiendo datos brutos en información procesable mediante operaciones intuitivas y de alto rendimiento.

En este módulo profundizaremos en las técnicas fundamentales que te permitirán:

• Seleccionar subconjuntos específicos de tus datos
• Transformar valores según necesidades analíticas
• Agregar y resumir información
• Combinar múltiples fuentes de datos

Estas habilidades esenciales forman la columna vertebral de cualquier proyecto de análisis, independientemente del sector o nivel de complejidad.

import pandas as pd
import numpy as np

## Creamos un DataFrame de ejemplo
datos = {
    'producto': ['Laptop', 'Smartphone', 'Tablet', 'Auriculares', 'Monitor'],
    'precio': [1200, 800, 500, 100, 300],
    'stock': [15, 25, 10, 30, 5],
    'categoría': ['Informática', 'Móviles', 'Informática', 'Audio', 'Informática'],
    'fecha_actualización': ['2023-01-15', '2023-01-20', '2023-01-10', '2023-01-25', '2023-01-05']
}

df = pd.DataFrame(datos)
df['fecha_actualización'] = pd.to_datetime(df['fecha_actualización'])

print(df)

2. Selección y filtrado de datos

La capacidad para extraer subconjuntos precisos de información es fundamental en el análisis de datos. Pandas ofrece múltiples métodos para seleccionar exactamente lo que necesitas.

2.1. Métodos básicos de selección

Para seleccionar columnas específicas puedes utilizar varias notaciones:

## Seleccionar una columna (devuelve una Series)
precios = df['precio']

## Seleccionar múltiples columnas (devuelve un DataFrame)
productos_precios = df[['producto', 'precio']]

La selección de filas por posición se realiza mediante slicing o métodos específicos:

## Seleccionar la primera fila
primera_fila = df.iloc[0]

## Seleccionar las tres primeras filas
primeras_filas = df[:3]

## Seleccionar filas del índice 1 al 3 (sin incluir el 4)
filas_intermedias = df.iloc[1:4]

2.2. Filtrado condicional

El filtrado por condiciones permite extraer datos que cumplen criterios específicos:

## Productos con precio mayor a 500
productos_caros = df[df['precio'] > 500]

## Productos de la categoría 'Informática'
informatica = df[df['categoría'] == 'Informática']

## Productos caros de informática (combinando condiciones)
informatica_caros = df[(df['categoría'] == 'Informática') & (df['precio'] > 300)]

## Productos con stock bajo o precio alto
atencion_especial = df[(df['stock'] < 10) | (df['precio'] > 1000)]

2.3. Loc e iloc para selección precisa

Los métodos loc e iloc ofrecen control avanzado sobre la selección:

## iloc: selección basada en posición (índices numéricos)
elemento = df.iloc[2, 3]  # Valor en la fila 2, columna 3
fila_columnas = df.iloc[0, [0, 2, 4]]  # Primera fila; columnas 0, 2 y 4

## loc: selección basada en etiquetas
df_subset = df.loc[1:3, ['producto', 'precio']]

## Selección condicional con loc
productos_seleccionados = df.loc[df['stock'] > 20, ['producto', 'precio', 'stock']]

2.4. Método query para filtrado expresivo

El método query proporciona una sintaxis más legible para filtros complejos:

## Equivalente a df[(df['precio'] > 300) & (df['stock'] >= 10)]
resultado = df.query('precio > 300 and stock >= 10')

## Uso de variables en query
precio_minimo = 300
categoria_buscada = 'Informática'
resultado = df.query('precio > @precio_minimo and categoría == @categoria_buscada')

2.5. Selección basada en fechas

Para datos temporales, Pandas ofrece métodos específicos de filtrado:

## Productos actualizados después de una fecha
recientes = df[df['fecha_actualización'] > '2023-01-15']

## Utilizar métodos de datetime para filtrado más granular
enero_medio = df[df['fecha_actualización'].dt.day > 15]

3. Transformación de datos

La transformación de datos nos permite modificar y adaptar la información para satisfacer nuestras necesidades analíticas específicas.

3.1. Aplicación de funciones con apply y map

Estas funciones permiten realizar transformaciones personalizadas:

## apply en Series: aplicar función a cada elemento
df['precio_con_iva'] = df['precio'].apply(lambda x: x * 1.21)

## apply en DataFrame: aplicar función a filas o columnas
df['resumen'] = df.apply(lambda row: f"{row['producto']} - {row['precio']}€", axis=1)

## map: transformar valores en una Series mediante un diccionario o función
categorias_simplificadas = {'Informática': 'Tech', 'Móviles': 'Tech', 'Audio': 'Audio'}
df['categoria_simple'] = df['categoría'].map(categorias_simplificadas)

## map: aplicar función a cada elemento del DataFrame
df_formateado = df[['precio', 'stock']].map(lambda x: f"{x:,}")

3.2. Modificación de valores con replace y where

Para sustituir valores específicos o aplicar cambios condicionales:

## Reemplazar valores
df['categoría'] = df['categoría'].replace('Móviles', 'Smartphones')

## Reemplazar múltiples valores
df['categoría'] = df['categoría'].replace({'Audio': 'Sonido', 'Informática': 'Computación'})

## where: reemplazar valores según condición
df['precio_rebajado'] = df['precio'].where(df['stock'] > 20, df['precio'] * 0.9)

3.3. Conversión de tipos de datos

La conversión de tipos es crucial para asegurar operaciones correctas:

## Convertir a numérico
df['precio'] = pd.to_numeric(df['precio'], errors='coerce')

## Convertir a categórica (útil para optimizar memoria)
df['categoría'] = df['categoría'].astype('category')

## Convertir a datetime
df['fecha_actualización'] = pd.to_datetime(df['fecha_actualización'])

## Conversiones múltiples con astype
conversiones = {'precio': 'float32', 'stock': 'int32'}
df = df.astype(conversiones)

3.4. Creación de columnas basadas en cálculos

Añadir nuevos campos calculados es una operación habitual:

## Columna simple basada en cálculo
df['valor_inventario'] = df['precio'] * df['stock']

## Columna basada en múltiples condiciones
df['nivel_stock'] = np.where(df['stock'] > 20, 'Alto', 
                            np.where(df['stock'] > 10, 'Medio', 'Bajo'))

## Cálculos utilizando métodos encadenados
df['precio_relativo'] = df['precio'] / df['precio'].mean()
df['precio_normalizado'] = (df['precio'] - df['precio'].min()) / (df['precio'].max() - df['precio'].min())

4. Operaciones con filas y columnas

El manejo eficiente de la estructura de tus datos es fundamental para adaptarlos a tus necesidades analíticas.

4.1. Añadir filas y columnas

Para expandir tus datos con nueva información:

## Añadir una nueva columna
df['descuento'] = 0.05

## Añadir columna basada en lógica condicional
df['precio_final'] = df['precio'] * (1 - df['descuento'])

## Añadir fila utilizando loc
nuevo_indice = len(df)
df.loc[nuevo_indice] = ['Webcam', 50, 20, 'Informática', '2023-01-30', 0.05, 47.5]

## Añadir fila mediante concat
nuevo_producto = pd.DataFrame([['Teclado', 45, 15, 'Informática', '2023-01-28', 0.05, 42.75]], 
                            columns=df.columns)
df = pd.concat([df, nuevo_producto], ignore_index=True)

4.2. Eliminar filas y columnas

Para simplificar tu DataFrame eliminando elementos innecesarios:

## Eliminar columnas
df_reducido = df.drop(columns=['descuento'])

## Eliminar múltiples columnas
df_esencial = df.drop(columns=['descuento', 'fecha_actualización'])

## Eliminar filas por índice
df_sin_primero = df.drop(index=0)

## Eliminar filas por condición
df_filtrado = df.drop(index=df[df['stock'] < 10].index)

4.3. Renombrar columnas

Para mejorar la claridad y consistencia de tus datos:

## Renombrar una columna
df = df.rename(columns={'precio': 'precio_base'})

## Renombrar múltiples columnas
df = df.rename(columns={'precio_base': 'precio', 'categoría': 'categoria'})

## Convertir nombres a minúsculas
df.columns = df.columns.str.lower()

## Reemplazar espacios por guiones bajos
df.columns = df.columns.str.replace(' ', '_')

4.4. Reordenar filas y columnas

La reorganización de datos mejora la legibilidad y facilita el análisis:

## Reordenar columnas
columnas_ordenadas = ['producto', 'categoria', 'precio', 'stock', 'fecha_actualizacion']
df = df[columnas_ordenadas]

## Ordenar filas por un valor
df_ordenado_precio = df.sort_values('precio', ascending=False)

## Ordenar por múltiples columnas
df_ordenado = df.sort_values(['categoria', 'precio'])

## Ordenar índice
df_indice_ordenado = df.sort_index()

El análisis agregado de datos es una de las operaciones más frecuentes en proyectos de inteligencia de negocio y ciencia de datos. Pandas implementa el patrón split-apply-combine a través de groupby(): primero divide el DataFrame en grupos según una o varias columnas, luego aplica una función de agregación a cada grupo y finalmente combina los resultados en un nuevo DataFrame. Los métodos agg(), transform() y filter() y la sintaxis de named aggregation permiten expresar agrupaciones complejas de forma concisa y eficiente.

La reestructuración de datos complementa la agrupación cuando se necesita cambiar la forma del DataFrame para análisis o visualización. pivot_table() genera tablas dinámicas con valores agregados, crosstab() calcula frecuencias cruzadas entre variables categóricas, melt() transforma columnas en filas para formatos largo (tidy data), y stack() y unstack() permiten pivotar índices de filas a columnas y viceversa en DataFrames con MultiIndex.

La limpieza de datos es una de las tareas esenciales en el análisis y ciencia de datos, ya que permite corregir o eliminar información incorrecta, duplicada o incompleta que afectaría negativamente cualquier análisis posterior. En este módulo, aprenderás las principales técnicas de limpieza de datos con la biblioteca pandas.

Identificación de datos faltantes con pandas

Uno de los primeros pasos al realizar la limpieza de datos es identificar los valores faltantes. En pandas, estos datos suelen representarse como NaN (Not a Number). La función más utilizada para esta tarea es isnull():

import pandas as pd

datos = {'nombre': ['Ana', 'Carlos', None, 'Lucía'],
         'edad': [25, None, 30, 28]}
df = pd.DataFrame(datos)

df.isnull()

La función isnull() devuelve un DataFrame booleano indicando con True dónde existen datos faltantes.

También es posible utilizar el método info() para obtener una visión rápida de la cantidad de valores no nulos por columna:

df.info()

Tratamiento de valores faltantes

Una vez identificados los valores faltantes, pandas ofrece varias opciones para su tratamiento:

• Eliminar filas con valores faltantes: Mediante el método dropna().

df_limpio = df.dropna()

• Eliminar columnas con demasiados valores faltantes: especificando axis=1.

df_limpio_columnas = df.dropna(axis=1)

• Rellenar valores faltantes: Usando fillna().

## Rellenar con un valor específico
df_rellenado = df.fillna({'nombre': 'Desconocido', 'edad': df['edad'].mean()})

Utilizar la media, la mediana o la moda de los datos para rellenar valores faltantes numéricos suele ser la mejor opción, ya que permite mantener las características estadísticas del conjunto.

Detección de valores duplicados

La presencia de datos duplicados puede distorsionar significativamente los resultados de análisis estadísticos. pandas permite detectar fácilmente estos registros mediante el método duplicated():

datos = {'id': [1, 2, 2, 3], 'producto': ['libro', 'lápiz', 'lápiz', 'bolígrafo']}
df = pd.DataFrame(datos)

duplicados = df.duplicated()
print(duplicados)

Este método devuelve una serie booleana indicando las filas duplicadas.

La capacidad de integrar pandas con otras bibliotecas de Python como NumPy, Matplotlib y Seaborn permite potenciar considerablemente el alcance y eficiencia de tus análisis y visualizaciones. En este módulo veremos cómo se complementan estas herramientas para realizar un trabajo más completo y eficiente.

Integración de pandas con NumPy

NumPy es una biblioteca especializada en operaciones numéricas y algebraicas sobre grandes matrices multidimensionales. pandas está construido sobre NumPy, por lo que ambas herramientas trabajan de forma conjunta de manera natural y eficiente.

Convertir estructuras pandas en arrays de NumPy

Convertir un DataFrame o una Serie en un array de NumPy es una operación sencilla que se realiza utilizando el método to_numpy():

import pandas as pd
import numpy as np

df = pd.DataFrame({'ventas': [150, 200, 175, 220]})

array_ventas = df['ventas'].to_numpy()
print(array_ventas)

El método to_numpy() es la forma recomendada frente al atributo .values, ya que permite especificar el tipo de dato de salida y gestiona de forma coherente los tipos nullable y PyArrow.

Operaciones matemáticas vectorizadas

La integración directa con NumPy permite que puedas aplicar operaciones vectorizadas eficientemente sobre columnas enteras de un DataFrame. Por ejemplo, calcular rápidamente el logaritmo o raíz cuadrada:

df['log_ventas'] = np.log(df['ventas'])
df['raiz_ventas'] = np.sqrt(df['ventas'])

Estas operaciones son extremadamente rápidas debido a la implementación interna optimizada en C que NumPy ofrece.

Crear DataFrames a partir de arrays NumPy

También puedes crear rápidamente DataFrames desde arrays NumPy utilizando pandas:

datos_np = np.array([[100, 150], [200, 250]])
df_nuevo = pd.DataFrame(datos_np, columns=['enero', 'febrero'])

Esto facilita enormemente transformar resultados numéricos en estructuras más cómodas para su análisis y visualización posterior.

Integración de pandas con Matplotlib

Matplotlib es la biblioteca de visualización más utilizada en Python y funciona perfectamente en combinación con pandas. La unión entre estas dos herramientas facilita enormemente la generación de gráficos rápidos y efectivos directamente desde DataFrames y Series.

Visualización directa desde pandas

Puedes visualizar datos directamente desde pandas usando el método plot() integrado:

import matplotlib.pyplot as plt

df = pd.DataFrame({'mes': ['Ene', 'Feb', 'Mar'],
                   'ventas': [250, 300, 400]})
                   
df.plot(x='mes', y='ventas', kind='bar', title='Ventas mensuales')
plt.xlabel('Mes')
plt.ylabel('Ventas (€)')
plt.show()

Este método simplifica considerablemente la creación de gráficos básicos sin necesidad de transformar manualmente los datos.

Personalización avanzada de gráficos

Para lograr una personalización avanzada, puedes extraer directamente las columnas del DataFrame en las funciones estándar de Matplotlib:

plt.figure(figsize=(8,4))
plt.plot(df['mes'], df['ventas'], marker='o', linestyle='--')
plt.title('Ventas por mes')
plt.xlabel('Mes')
plt.ylabel('Ventas (€)')
plt.grid(True)
plt.show()

De este modo puedes aprovechar toda la flexibilidad que Matplotlib ofrece, utilizando pandas para gestionar previamente tus datos de manera sencilla.

Integración de pandas con Seaborn

Seaborn es una biblioteca basada en Matplotlib que permite crear gráficos estadísticos con mayor facilidad y elegancia visual. pandas facilita el uso de Seaborn al proporcionar estructuras de datos compatibles y fáciles de integrar.

Creación sencilla de gráficos estadísticos

Con pandas y Seaborn puedes crear gráficos estadísticos complejos de manera sencilla, como diagramas de cajas o histogramas:

import seaborn as sns

df = pd.DataFrame({'ventas': [150, 170, 250, 300, 200, 220]})

sns.boxplot(x=df['ventas'])
plt.title('Distribución de las ventas')
plt.xlabel('Ventas (€)')
plt.show()

Esto te permite visualizar rápidamente la distribución y variabilidad de tus datos con gráficos estadísticos intuitivos.

Gráficos avanzados usando DataFrames

Una ventaja importante de Seaborn es su capacidad para generar gráficos avanzados con facilidad desde DataFrames pandas, como el diagrama de dispersión categórico (catplot) o gráficos de correlación (heatmap):

datos = {'categoría': ['A', 'A', 'B', 'B'],
         'valor': [10, 15, 12, 18]}
df = pd.DataFrame(datos)

sns.catplot(x='categoría', y='valor', data=df, kind='swarm')
plt.title('Distribución de valores por categoría')
plt.show()

Para gráficos de correlación:

df_corr = pd.DataFrame({'x': np.random.rand(100),
                        'y': np.random.rand(100)})

sns.heatmap(df_corr.corr(), annot=True)
plt.title('Mapa de correlación')
plt.show()

Esto simplifica considerablemente la creación de visualizaciones estadísticas complejas directamente a partir de DataFrames.

A medida que los conjuntos de datos crecen en tamaño y los pipelines de datos deben ejecutarse en producción con restricciones de tiempo y memoria, el rendimiento de Pandas pasa a ser un factor crítico. Pandas 2.2 activa Copy-on-Write por defecto, lo que elimina efectos secundarios inesperados en asignaciones encadenadas y reduce las copias innecesarias de datos en memoria. El backend PyArrow permite usar columnas con ArrowDtype que consumen menos memoria y aceleran operaciones de lectura de Parquet y CSV gracias al motor columnar nativo.

Las funciones eval() y query() delegan la evaluación de expresiones a un motor nativo (numexpr) que opera sobre arrays en memoria contigua, lo que supera a los bucles Python explícitos para DataFrames de millones de filas. La vectorización y el uso de métodos nativos de Pandas (apply con axis=1 solo cuando no hay alternativa vectorizada) minimizan el overhead del intérprete. El encadenamiento de métodos con pipe() y el estilo funcional facilitan la legibilidad y el testeo de pipelines de transformación, requisitos habituales en proyectos de analítica empresarial con múltiples pasos de preprocesado.

Los índices jerárquicos (MultiIndex) permiten representar datos multidimensionales dentro de la estructura tabular de un DataFrame, algo habitual en análisis financiero, geográfico o de series temporales con múltiples niveles de agrupación. El módulo cubre set_index con varias columnas, selección con loc y tuplas, pd.IndexSlice para rangos, xs() para cortes transversales, y las operaciones unstack() y stack() para reestructurar niveles del índice.

Las funciones de ventana son esenciales en análisis de series temporales y financieras: rolling() calcula estadísticas deslizantes sobre una ventana de N observaciones, expanding() acumula desde el inicio de la serie y ewm() aplica ponderación exponencial para dar más peso a observaciones recientes. Pandas 2.2 incorpora mejoras relevantes: Copy-on-Write activo por defecto, ArrowDtype para columnas nativas de PyArrow más eficientes en memoria, case_when() para lógica condicional vectorizada como alternativa a np.select, dtype_backend para elegir el motor de tipos en lectura de datos, y extensiones al tipo pd.NA para operaciones de comparación y lógica booleana con valores faltantes.