Manejo de Series con Pandas
Introducción a Manejo de Series con Pandas
La biblioteca Pandas es una herramienta fundamental en Python para el análisis y la manipulación de datos. Su estructura denominada Serie permite manejar información unidimensional de forma eficiente, combinando los beneficios de los arreglos de NumPy con un índice que identifica cada elemento. Gracias a las Series , es posible realizar operaciones estadísticas, filtrado, selección y transformación de datos de manera rápida y flexible, lo que convierte a Pandas en una opción ideal para el trabajo con conjuntos de datos en proyectos de ciencia de datos, ingeniería y análisis numérico.
Definición de Series
Una serie en pandas es una estructura de datos unidimensional que puede contener cualquier tipo de dato (enteros, strings, flotantes, objetos de Python, etc.). Es similar a una columna en una hoja de cálculo o una tabla de base de datos.
Cada elemento de una Series tiene un índice asociado, lo que facilita el acceso a los datos.
Características Clave
- Unidimensional: Solo tiene una columna de datos.
- Indexada: Cada valor tiene una etiqueta o índice asociado.
- Homogénea: Aunque puede contener diferentes tipos, generalmente se usa con un solo tipo de dato.
- Tamaño inmutable: Una vez creada, no puedes cambiar su tamaño (pero sí modificar valores).
- Permite operaciones matemáticas: Operaciones como suma, promedio, o multiplicación pueden aplicarse directamente.
Ejemplo Básico Creación de una Serie
import pandas as pd
# Crear una Serie simple
s = pd.Series([10, 20, 30, 40, 50])
print(s)
# Salida esperada:
# 0 10
# 1 20
# 2 30
# 3 40
# 4 50
# dtype: int64
# Serie con índices personalizados
serie_nombres = pd.Series([25, 30, 35], index=['Ana', 'Luis', 'María'])
print(serie_nombres)
# Salida esperada:
# Ana 25
# Luis 30
# María 35
# dtype: int64
Primera aproximación a las Series en Pandas
Una Serie en Pandas se utiliza para almacenar y manipular datos unidimensionales, acompañados por un índice que identifica cada elemento. Es ideal para representar una columna de datos, una lista de valores o una secuencia etiquetada.
Para utilizar una Serie, se debe importar la biblioteca Pandas y crear un objeto de tipo Series. A partir de allí, es posible acceder, modificar, filtrar y realizar operaciones matemáticas o estadísticas sobre los datos.
A continuación, se describe el proceso completo paso a paso, de cmo se usa la biblioteca Pandas:
Instalación de la Biblioteca Pandas
Para instalar Pandas, se utiliza el gestor de paquetes pip, que es la herramienta estándar de Python para instalar bibliotecas externas.
pip install pandas # Terminal / Línea de comandos
!pip install pandas # Notebooks (Jupyter, Google Colab, etc.)
Este comando descarga e instala la versión más reciente de Pandas junto con sus dependencias (como NumPy).
Importación de la Biblioteca
Una vez instalada, es necesario importarla en el código para poder utilizar sus funciones y
estructuras. Por convención, se importa con el alias pd:
import pandas as s
Mostrar la ejecución de Celda Completa
Para que se pueda ver todos los resultados en cada celda ejecutar:
from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.ast_node_interactivity = "all"
Creación y Uso de una Serie
Una Serie es una estructura unidimensional de Pandas, similar a una columna de una hoja de cálculo o a un arreglo de NumPy, que puede contener distintos tipos de datos (números, cadenas, booleanos, etc.).
Ejemplo básico:
# Crear una Serie a partir de una lista de Python
datos = [10, 10, 30, 40, 40, 40, 70, 80, 90, 100]
s = pd.Series(datos)
print(s)
# Salida esperada
# 0 10
# 1 10
# 2 30
# 3 40
# 4 40
# 5 40
# 6 70
# 7 80
# 8 90
# 9 100
# dtype: int64
Personalización de índices
Se pueden asignar índices personalizados en lugar de los numéricos por defecto:
Ejemplo básico:
s = pd.Series(datos, index=["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"])
print(s)
# Salida esperada:
# A 10
# B 10
# C 30
# D 40
# E 40
# F 40
# G 70
# H 80
# I 90
# J 100
# dtype: int64
Acceso y operaciones con una Serie
Pandas permite acceder y operar sobre los datos fácilmente:
print("B =", s["B"]) # Acceder por etiqueta → 20
print("Promedio =", s.mean(),"\n") # Calcular el promedio → 51.0
print(s + 5) # Operaciones vectorizadas
# Salida esperada:
# B = 10
# Promedio = 51.0
#
# A 15
# B 15
# C 35
# D 45
# E 45
# F 45
# G 75
# H 85
# I 95
# J 105
# dtype: int64
Sentencias para Manejo de Series
Las sentencias para el manejo de Series en Pandas constituyen un conjunto de instrucciones que permiten crear, modificar, acceder y analizar datos de manera estructurada y eficiente. Mediante estas sentencias, es posible realizar operaciones como filtrado, selección de elementos, cálculos estadísticos y transformaciones sobre colecciones unidimensionales de datos. Su uso facilita el trabajo con información numérica o categórica, optimizando procesos de análisis y preparación de datos dentro del entorno de Python.
Creación de Series
Estas sentencias permiten crear o definir una Serie a partir de diferentes estructuras de datos de Python.
Sintaxis básica:
pd.Series(data, index=None, dtype=None)
Fuentes de datos comunes:
- Lista:
pd.Series([10, 20, 30, 40, 50])import pandas as pd data = [10, 20, 30, 40, 50] s = pd.Series(data) print(s) # Salida esperada: # 0 10 # 1 20 # 2 30 # 3 40 # 4 50 # dtype: int64 - Diccionario:
pd.Series({"a": 10, "b": 20, "c":30, "d":40, "e":50})import pandas as pd data = pd.Series({"a": 10, "b": 20, "c":30, "d":40, "e":50}) s_dict = pd.Series(data) print(s_dict) # Salida esperada: # a 10 # b 20 # c 30 # d 40 # e 50 # dtype: int64 - Arreglo NumPy:
pd.Series(np.array([1, 2, 3]))
Exploración y Análisis de la Serie
Comandos para inspeccionar la estructura, el contenido y las características básicas de la Serie.
s.head() # Muestra los 5 primeros elementos
s.head(n) # Muestra los n primeros elementos
s.tail() # Muestra los 5 últimos elementos
s.tail(n) # Muestra los n últimos elementos
s.ndim # Dimensión (1 para Series)
s.shape # Tamaño (número de elementos), devuelve una tupla (n,)
s.size # Número total de elementos, devuelve una entero n
s.index # Devuelve las etiquetas del índice
s.values # Devuelve los valores como un array
s.name # Nombre de la Serie
s.dtype # Tipo de datos de la Serie
s.describe() # Estadísticas descriptivas
s.info() # Información general de la Serie
Salida esperada para s.dtype:
| Tipo de dato | Descripción | Ejemplo de contenido |
|---|---|---|
int64 |
Números enteros (enteros grandes) | [10, 20, 30] |
int32 |
Enteros de 32 bits (en algunos sistemas) | [1, 2, 3] |
float64 |
Números decimales (flotantes) | [1.2, 3.5, 4.8] |
float32 |
Flotantes de precisión simple | [1.1, 2.2, 3.3] |
object |
Cadenas de texto o datos mixtos | ['a', 'b', 'c'] |
bool |
Valores lógicos (True / False) | [True, False, True] |
datetime64[ns] |
Fechas y horas con precisión de nanosegundos | ['2023-01-01', '2023-02-01'] |
timedelta64[ns] |
Diferencias de tiempo o duraciones | pd.Series(pd.to_timedelta(['1 days', '2 days'])) |
category |
Datos categóricos (optimizan memoria) | ['bajo', 'medio', 'alto'] (convertidos a categorías) |
string |
Tipo de texto moderno de Pandas (desde v1.0) | pd.Series(['uno', 'dos'], dtype='string') |
complex128 |
Números complejos | [1+2j, 3+4j] |
Salida esperada para s.describe(): analiza el contenido de la Serie y
devuelve estadísticas resumidas, pero su resultado depende del tipo de datos que contenga la Serie:
- Si los datos son numéricos,
s.describe()mostrará medidas estadísticas:0 count 5.000000 # Cantidad de valores no nulos. mean 30.000000 # Media (promedio). std 15.811388 # Desviación estándar. min 10.000000 # Valor mínimo. 25% 20.000000 # Primer cuartil (25%). 50% 30.000000 # Mediana (50%). 75% 40.000000 # Tercer cuartil (75%). max 50.000000 # Valor máximo dtype: float64 - Si los datos son categóricos o de texto,
s_dict.describe()mostrará medidas de frecuencia.count 6 unique 3 top rojo freq 3 dtype: object
Acceso y Selección de Datos
Métodos para acceder, indexar o filtrar datos en una Serie.
s[0] # Acceso por posición
s["A"] # Acceso por etiqueta
s.loc["A"] # Acceso por etiqueta (explícito)
s.iloc[0] # Acceso por posición (explícito)
s[["A", "B"]] # Selección múltiple
s[serie > 10] # Filtrado condicional
Ejemplo:
# Se crea una serie con etiquetas personalizadas.
s = pd.Series(
[5, 12, 7, 20, 3],
index=["A", "B", "C", "D", "E"]
)
valor = s[0]
print("valor en posición 0 =>", valor) # -> 5
valor = s.iloc[0]
print("valor en posición 0 =>", valor) # -> 5
valor = s["B"]
print("valor en la etiqueta B =>",valor) # -> 12
valor = s.loc["B"]
print("valor en la etiqueta B =>",valor) # -> 12
sub = s[["A", "B"]]
print("valor en las etiqueta A y B =>\n",sub)
# A 5
# B 12
filtrada = s[s > 10]
print("filtrado para valores > 10 =>\n",filtrada)
# B 12
# D 20
Operaciones Matemáticas y Estadísticas
Métodos para realizar operaciones numéricas y estadísticas sobre los datos.
s = pd.Series(
[5, 20, 7, 20, 7, 20, 7],
index=["A", "B", "C", "D", "E", "F", "G"]
)
print("Suma total", s.sum()) # 86
print("Promedio", s.mean()) # 12.285714285714286
print("Mediana", s.median()) # 7.0
print("Moda\n", s.mode())
# 0 7 se repite tres veces
# 1 20 se repite tres veces
# dtype: int64
print("Desviación estándar", s.std()) # 7.250615737399726
print("Valor mínimo", s.min()) # 5
print("Valor máximo", s.max()) # 20
print("Varianza", s.var()) # 52.57142857142858
print("Suma acumulativa\n", s.cumsum())
# A 5
# B 25
# C 32
# D 52
# E 59
# F 79
# G 86
# dtype: int64
print("Producto acumulativo\n", s.cumprod())
# A 5
# B 100
# C 700
# D 14000
# E 98000
# F 1960000
# G 13720000
# dtype: int64
print("Frecuencia de valores únicos\n", s.value_counts())
# 20 3
# 7 3
# 5 1
# Name: count, dtype: int64
Manipulación y Transformación de Datos
Sentencias para modificar o transformar los valores de una Serie.
Sintaxis básica:
s = pd.Series(
[5, 20, 7, 20, 7, 20, 7],
index=["A", "B", "C", "D", "E", "F", "G"]
)
s.add(n) # Le suma n a cada elemento de la serie
s.sub(n) # Le resta n
s.mul(n) # Le Multiplica n
s.div(n) # Divide en n
s.round(n) # Redondeo a n decimales
s.replace(val_ant, val_nuevo) # Reemplaza valores
s.astype(tipo) # Cambia el tipo de dato
s.apply(función) # Aplica una función personalizada
s.map(función) # Mapea valores mediante una función o diccionario
Limpieza y Tratamiento de Valores Nulos
Métodos esenciales para detectar, eliminar o reemplazar valores faltantes:
import pandas as pd
import numpy as np
# Crear una Serie con algunos valores nulos
s = pd.Series(
[5, np.nan, 7, 20, np.nan, 15, 7],
index=["A", "B", "C", "D", "E", "F", "G"]
)
s.isna() # Detecta valores nulos (True/False)
s.notna() # Detecta valores no nulos
s.dropna() # Elimina valores nulos
s.fillna(-1) # Sustituye valores nulos por -1
s.replace(np.nan, 0) # Reemplaza nulos por cero
Operaciones con Índices
Sentencias que permiten gestionar o modificar el índice de una Serie.
s = pd.Series(
[5, 20, 7, 20, 7, 20, 7],
index=["A", "B", "C", "D", "E", "F", "G"]
)
nuevo_indice = ["G", "E", "C", "A", "B", "D", "F"]
s.index # Muestra el índice
s = s.reindex(nuevo_indice) # Asigna un nuevo índice, se crea una nueva serie
s.index # Muestra el nuevo índice
s = s.reset_index() # Reinicia el índice, convierte el índice actual
# en una columna y asigna un nuevo índice numérico por defecto
s.index # Muestra la nueva serie
s.rename_axis("Título") # Renombra título del índice
s.sort_index() # Ordena por índice
s.sort_values() # Ordena por valores
Combinación y Concatenación de Series
Permiten unir o concatenar varias Series entre sí:
s1 = pd.Series([1, 2, 3])
s2 = pd.Series([11, 12, 13])
s_concatenated = pd.concat([s1, s2])
Exportación de Datos
Métodos para guardar o exportar el contenido de una Serie.
s.to_csv("datos.csv") # Exporta a CSV
s.to_excel("datos.xlsx") # Exporta a Excel
s.to_json("datos.json") # Exporta a JSON
s.to_dict() # Convierte a diccionario, Devuelve un diccionario de Python estándar
# donde las claves son los índices y los valores son los datos de la Serie.
s.to_list() # Convierte a lista, devuelve únicamente los valores, sin incluir el índice
Importación de Datos
Métodos para importar el contenido de una Serie des archivos, clipboard, etc.
pd.read_csv("datos.csv") # Importa datos desde un archivo CSV
pd.read_excel("datos.xlsx") # Importa datos desde un archivo Excel
pd.read_json("datos.json") # Importa datos desde un archivo JSON
pd.read_html("pagina.html") # Importa tablas desde una página web (HTML)
pd.read_table("datos.txt") # Importa datos desde un archivo de texto delimitado
pd.read_clipboard() # Importa datos copiados desde el portapapeles
pd.read_sql("SELECT * FROM tabla", conexion) # Importa datos desde una base de datos SQL
pd.read_parquet("datos.parquet") # Importa datos en formato Parquet (alta eficiencia)
pd.read_feather("datos.feather") # Importa datos en formato Feather (rápido y ligero)
pd.read_pickle("datos.pkl") # Importa objetos serializados en formato Pickle
Ejemplo: Como importar un archivo CSV:
df = pd.read_csv("datos.csv", index_col=0)
s3 = pd.Series(df.iloc[:, 0])
s3_ordenada = s3.sort_values()
print(s3_ordenada)
Métodos Avanzados y Utilitarios
Opciones adicionales para análisis más profundo o depuración.
import pandas as pd
import numpy as np
s = pd.Series([10, 20, 30, 20, 40, 10, 50, np.nan, 60, 70])
s4 = pd.Series([10, 20, 30, 20, 40, 10, 50, np.nan, 60, 70])
s.unique() # Valores únicos: [10. 20. 30. 40. 50. nan 60. 70.]
s.nunique() # Cantidad de valores únicos, 7
s.sample(3) # Muestra aleatoria
# 5 10.0
# 3 20.0
# 8 60.0
s.clip(0, n) # Limita valores dentro de un rango
# si n = 40
# 0 10.0
# 1 20.0
# 2 30.0
# 3 20.0
# 4 40.0
# 5 10.0
# 6 40.0
# 7 NaN
# 8 40.0
# 9 40.0
# dtype: float64
s.between(n1, n2) # Verifica rango de valores, n1 y n2
# si n1 = 10 y n2 = 50
# 0 True
# 1 True
# 2 True
# 3 True
# 4 True
# 5 True
# 6 True
# 7 False
# 8 False
# 9 False
# dtype: bool
s.equals(s4) # Compara Series si son iguales => True
# si cambia cualquier cosa => False
Manejo de Funciones de Cadena str
Para poder usar las funciones de texto, se utiliza:
s.str.función()
Ejemplo:
import pandas as pd
s = pd.Series(['Python', 'pandas', 'Datos', 'Análisis'])
# Convertir todo a minúsculas
s_lower = s.str.lower()
print(s_lower)
Funciones de Formato de Texto
str.lower() # Convierte a minúsculas
str.upper() # Convierte a mayúsculas
str.title() # Convierte a formato título
str.capitalize() # Capitaliza la primera letra
str.strip() # Elimina espacios al inicio y final
str.replace(a, b) # Reemplaza texto => s.str.replace('a', '@')
str.pad(width, side, fillchar) # Rellena con caracteres => s.str.pad(width, side='right/left/both', fillchar='-')
Extracción y División de Texto
str.split(sep) # Divide la cadena en partes s.str.split(' ')
str.get(i) # Obtiene el elemento i de una lista resultante s.str.split(' ').str.get(0)
Búsqueda y Conteo de Texto
str.slice(start, stop) # Extrae subcadenas por posición
str.extract(patrón) # Extrae datos con expresiones regulares s.str.extract('(\d+)')
Búsqueda y conteo str.contains(patrón) # Verifica si contiene un texto
str.startswith(patrón) # Verifica si empieza con texto
str.endswith(patrón) # Verifica si termina con texto
str.count(patrón) # Cuenta ocurrencias del patrón
Longitud y Validación de Texto
str.len() # Devuelve la longitud de cada texto
str.isalpha() # Verifica si son solo letras
str.isnumeric() # Verifica si son solo números
str.isalnum() # Verifica si son solo letras y/o números, False si contiene símbolos y espacios