Pandas: Estructuras de datos

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