Mostrando entradas con la etiqueta Pandas. Mostrar todas las entradas
Mostrando entradas con la etiqueta Pandas. Mostrar todas las entradas

viernes, 15 de mayo de 2026

DATOS. Tratamiento de datos

Limpieza de datos (II)

Normalización de datos

Cuando en la tabla-formulario de un documento de texto cabe la posibilidad de que los datos se expresen de diferentes maneras, existe una elevada probabilidad de que así sea. Aunque predomine una determinada forma, vamos a decir que canónica, es altamente probable que también se empleen otras formas que no lo son tanto. Un buen ejemplo de ello lo tienes en la tabla que sigue.

Como puedes ver en este ejemplo ficticio, que no lo es en este aspecto de la variabilidad de expresión de la fecha, junto a la forma canónica (círculo naranja), nos encontramos con otras forma diferentes (por ejemplo, pero no sólo, la marcada con el círculo verde). Aunque para un análisis visual de los datos esto no supone ningún problema (salvo en casos muy concretos), para el tratamiento automatizado de los datos se convierte en un serio problema: esas fecha no-canónicas no son reconocidas como tales fechas. Para evitar la pérdida de datos que esto implica, es necesario convertir estos datos al formato fecha. Podemos hacerlo manualmente, con ayuda de las funciones de formato de Calc (o Excel), aunque esto nos llevará tiempo. También contamos con la opción de automatizar el reajuste de formato mediante un script Python como el que sigue.



# 0. Bibliotecas y módulos ---

import pandas as pd
import re
from datetime import datetime

# 1. Funciones ---

# 1.a Función secundaria. Transforma string en fechas ---

def normalizar_fecha(texto):

    if pd.isna(texto) or str(texto).strip() == "":
        return None
    
    dato = str(texto).lower().strip()
    
    meses_map = {
        'enero': 1, 'febrero': 2, 'marzo': 3, 'abril': 4, 'mayo': 5, 'junio': 6,
        'julio': 7, 'agosto': 8, 'septiembre': 9, 'octubre': 10, 'noviembre': 11, 'diciembre': 12
    }

    try:
        return pd.to_datetime(dato, dayfirst=True).date()     # Intento 1: Formato numérico completo (ej. 2/02/2026)
    except:
        pass
    anio_detectado = re.search(r'(\d{4})', dato)               # Intento 2: Formato parcial (ej. enero 2014)
    if anio_detectado:
        anio = int(anio_detectado.group(1))
        for mes_nombre, mes_numero in meses_map.items():
            if mes_nombre in dato:
                return datetime(anio, mes_numero, 1).date()      # Retornamos siempre el día 1 del mes encontrado
    return None                                                  # Si llega aquí, no se pudo convertir y devolvemos None

# 1.b Función principal ---

def procesar_limpieza(ruta_entrada, columna_objetivo, ruta_salida):
    
    try:
        print(f"Cargando archivo: {ruta_entrada}...")
        df = pd.read_csv(ruta_entrada, sep=';', encoding='utf-8')
        df['fecha_corregida'] = df[columna_objetivo].apply(normalizar_fecha)                # Aplicamos la normalización (funcion 1a)
        df['fecha_corregida'] = pd.to_datetime(df['fecha_corregida'], errors='coerce')      # Convertimos a datetime Pandas (AAAA-MM-DD)
        df.to_csv(ruta_salida, sep=';', index=False, encoding='utf-8')                      # Exportamos el resultado (csv)
        print(f"Éxito: Archivo '{ruta_salida}' generado con fechas estandarizadas.")
        
    except Exception as e:
        print(f"Error durante el proceso de código: {e}")

# 2. Script principal (Llamada a la función principal) ---

if __name__ == "__main__":

    archivo_origen = r''            # Aquí la ruta del archivo csv de trabajo
    columna_fechas = 'fecha'        # Aquí el nombre de la columna a procesar
    archivo_destino = r''      		# Aquí el nombre del csv resultante
    
    procesar_limpieza(archivo_origen, columna_fechas, archivo_destino) # Llamada a la función


La estructura del script es relativamente simple: dos funciones y un script. El script llama a la función principal pasando parámetros (procesar_limpieza(archivo_origen, columna_fechas, archivo_destino)) que el profesional asigna a variables (vg. archivo_origen = r'') y la función principal hace uso de la secundaria para tratar el contenido textual del campo y devolver un formato fecha del módulo datetime en formato Pandas (AAA-MM-DD).

La función principal es sumamente importante: (1) Carga el csv de trabajo, (2) Llama a la función secundaria para normalizar el formato (3) convierte el dato devuelto por esa función al formato datetime de Pandas y (4) genera el scv de salida.

  1. df = pd.read_csv(ruta_entrada, sep=';', encoding='utf-8')
  2. df['fecha_corregida'] = df[columna_objetivo].apply(normalizar_fecha)
  3. df['fecha_corregida'] = pd.to_datetime(df['fecha_corregida'], errors='coerce')
  4. df.to_csv(ruta_salida, sep=';', index=False, encoding='utf-8')

Pero la función secundaria no es menos interesante, como veremos a continuación. Recordemos:



def normalizar_fecha(texto):

    if pd.isna(texto) or str(texto).strip() == "":
        return None
    
    dato = str(texto).lower().strip()
    
    meses_map = {
        'enero': 1, 'febrero': 2, 'marzo': 3, 'abril': 4, 'mayo': 5, 'junio': 6,
        'julio': 7, 'agosto': 8, 'septiembre': 9, 'octubre': 10, 'noviembre': 11, 'diciembre': 12
    }

    try:
        return pd.to_datetime(dato, dayfirst=True).date()     # Intento 1: Formato numérico completo (ej. 2/02/2026)
    except:
        pass
    anio_detectado = re.search(r'(\d{4})', dato)               # Intento 2: Formato parcial (ej. enero 2014)
    if anio_detectado:
        anio = int(anio_detectado.group(1))
        for mes_nombre, mes_numero in meses_map.items():
            if mes_nombre in dato:
                return datetime(anio, mes_numero, 1).date()      # Retornamos siempre el día 1 del mes encontrado
    return None                                                  # Si llega aquí, no se pudo convertir y devolvemos None



En esta función podemos diferenciar varias partes:
  • Primero un procedimiento de control para cuando la variable texto está vacía o no es válida
  • A continuación la variable texto se convierte a str y se normaliza a minúscula, pasando esta doble conversión a la varible dato
  • Después construímos una diccionario de meses:numerales meses_map para capturar el contenido del campo que procesamos y que a esta función hemos pasado como parámetro def normalizar_fecha(texto)

Lo que viene a continuación es el núcleo central de la función, que se desarrolla dentro de una estructura de control de excepciones try...except, en la que la parte try controla la presencia en dato de la formulación de la fecha según el formato dd/mm/aaaa y la transformar una entrada un objeto de fecha puro Año-Mes-Día de la librería Pandas. La parte except controla la posible comisión de errores

Si la primera solución no resolvió el procesamiento de la variable, la segunda utiliza la expresión regular re.search(r'(\d{4})', dato) para localizar y obtener el dato año (4 dígitos dentro del texto) y si lo encuentra recorre el listado de meses para ver si el término nombre del mes está escrito en dato. Si lo está, sobre el dato año y la conversión numérica del dato mes se construye una fecha, usando 1 como dato día.

Con este script hemos normalizado reformulandolo el campo fecha para que sea posible trabajar con esta variable en la fase de análisis de datos. El resultado es una nueva columna o campo (fecha_corregida). Cierto que que no todos los datos se han podido modificar según lo esperado debido a que el dato original no se ajusta a las formas esperadas. esto puede dar lugar a una nueva pérdida de datos, aunque al ser una circunstancia controlada y de relativa poca importancia, también podemos optar por realizar una última revisión "manual" a fin de evitar una pérdida de datos innecesaria y no deseada. Llegados a este punto, no es una mala solución.

sábado, 9 de mayo de 2026

DATOS. Tratamiento de datos

Limpieza de datos (I)

Datos faltantes

Es muy frecuente que en una colección de datos de cierta entidad se observen campos en blanco o con una marca sustituta (ver tabla abajo), a consecuencia de diversos motivos, incluídos los errores de recogida de datos y la simple ausencia de éstos por no producirse determinada respuesta. Lo que en realidad importa para su tratamiento posterior es que las ausencias sean razonablemente escasas; en caso contrario, la calidad del conjunto de datos se ve muy seriamente comprometida.

Entorno Elemento
Python puro None
Data Science (Pandas/NumPy) NaN
Base de datos (SQL) NULL
Lenguaje R NA

Las opciones disponibles para hacer frente a esta realidad son varias, desde la eliminación del registro hasta el relleno del campo con determinado valor, resultante de algún tipo de cálculo. Para conocer cuales son esas alternativas, además de consultar a la IA, que lo que hace es resumir el conjunto de posibilidades disponibles, sustituyendo así a una simple búsqueda web, también podemos consultar alguna página específicamente pensada para tratar este tema. Yo aquí te ofrezco un ejemplo de la segunda opción; la primera corre de tu cuenta.

No es por comodidad, pero en este caso voy a optar por la forma más simple de resolver el problema: eliminando el registro. No es precisamente la mejor solución, especialmente cuando no disponemos de muchos registros, pero sí la más adecuada para un caso como el que nos ocupa en el que no hay la pretensión de representatividad estadística ni interés por crear un procedimiento de (aprendizaje automático (AA). Además, en este caso, en la mayoría de los registros faltan todos los datos que pueden faltar, dado que son resultado de una opción de tratamiento del documento que ahora no me intersa comentar; sirva con decir que las tablas simplemente no están cumplimentadas, por lo que es hasta coherente eliminar estos registros. Puede que no lo sea tanto en los casos en que sólo falta la fecha, pero son muy escasos y el riesgo real de pérdida de información es mínimo.



import pandas as pd
import os
import numpy as np

# --- Función ---

def limpiar_tabla_especifica(ruta_absoluta):
    if not os.path.exists(ruta_absoluta):
        print(f"Error: No se localiza el archivo en {ruta_absoluta}")
        return

    try:
        df = pd.read_csv(ruta_absoluta, sep=';', engine='python')   # 1. Carga los datos con el separador identificado (sep=';')
        total_inicial = len(df)                                     # Conteo inicial para calcular los registros afectados

        df = df.replace(r'^\s*$', np.nan, regex=True)               # 2. Convertir espacios vacíos (" ") en nulos reales (NaN)

        columnas_a_validar = ['fecha', 'SEO', 'OE']                 # 3. Eliminar registros si falta dato en fecha-SEO-OE
        df_limpio = df.dropna(subset=columnas_a_validar)

        total_final = len(df_limpio)                                # 4. Cálcular los registros eliminados
        eliminados = total_inicial - total_final

        ruta_directorio = os.path.dirname(ruta_absoluta)            # 5. Exportar el resultado a csv
        nombre_salida = "lista_t1_sin_nulos.csv"
        ruta_salida = os.path.join(ruta_directorio, nombre_salida)

        df_limpio.to_csv(ruta_salida, sep=';', index=False)

        print("-" * 30)                                              # 6. Informe a mostrar por consola
        print("INFORME DE PROCESAMIENTO")
        print("-" * 30)
        print(f"Registros analizados: {total_inicial}")
        print(f"Registros eliminados (faltaba fecha, SEO o OE): {eliminados}")
        print(f"Registros válidos restantes: {total_final}")
        print(f"Archivo generado: {ruta_salida}")

    except Exception as e:
        print(f"Se produjo un error durante la ejecución: {e}")

# --- Llamada a la función ---

ruta_csv = r"" 														# Aqui la ruta de tu archivo csv
limpiar_tabla_especifica(ruta_csv)                                  # Llamada a la función


Mediante este script eliminamos los registros que carecen de datos en las columnas (variables) de interés columnas_a_validar = ['fecha', 'SEO', 'OE'], cosa que sucede gracias al uso de la función df.dropna() de Pandas (df_limpio = df.dropna(subset=columnas_a_validar)). Al especificar el identificador de las columnas hacemos que el script sea dependiente de la tabla, a la vez que nos permite identificar lo que deberemos cambiar si cambiamos de tabla.

Y hablando de especificidades, debo decir que para que el script funcione ha sido necesario especificar el separador de campos de la tabla (df = pd.read_csv(ruta_absoluta, sep=';', engine='python')), ya que el csv-base utiliza ; en vez del esperado (,) por defecto por Pandas.

El resultado tiene una doble expresión: archivo como csv (comentario 5 del script) se muestra una síntesis por consola (comentario 6). No proporciono ninguna prueba por innecesaria; es suficiente con que pienses en la última tabla de esta entrada sin el registro INF_003.dot.

domingo, 1 de marzo de 2026

DATOS. Acceso a datos

CSV. Datos estructurados

Biblioteca Pandas. Acceso a .csv

Aunque el módulo nativo (CSV) es suficiente cuando la tabla de datos es sencilla y el volumen de datos que contiene moderado, para trabajar con bases de datos grandes y complejas es preferible usar la bibliteca Pandas. Por eso no vamos a dedicar al módulo nativo más tiempo del necesario, puesto que será Pandas la opción preferente: lo que sirve para lo mucho, sirve para lo poco. Ganamos tiempo.

Veamos cómo acceder a nuestra base de datos de libros ahora con Pandas.



import pandas as pd
import os

ruta_archivo = 'datos\libros3.csv'

def acceder_con_pandas():
    # 1. Verificar si el archivo existe
    if not os.path.exists(ruta_archivo):
        print(f"❌ El archivo '{ruta_archivo}' no se encuentra.")
        return

    try:
        # 2. Cargar el CSV
        # Pandas detecta automáticamente la cabecera
        df = pd.read_csv(ruta_archivo, encoding='utf-8')

        print("--- 🐼 Acceso Exitoso con Pandas ---")
        
        # 3. Visualización rápida
        print("\n📊 Resumen del contenido (Primeras 5 filas):")
        print(df.head())

        # 4. Información técnica (Nº filas, columnas y tipos de datos)
        print("\nℹ️ Información técnica:")
        df.info()

        # 5. Ejemplos de acceso directo
        if not df.empty:
            # Acceder a una columna específica (ej: 'Título')
            if 'Título' in df.columns:
                print("\n📖 Lista de Títulos:")
                print(df['Título'].to_list())

            # Acceder a un registro específico por su índice (ej: el primero)
            print("\n📍 Primer registro completo:")
            print(df.iloc[0])

    except UnicodeDecodeError:
        print("❌ Error de codificación. Prueba con encoding='latin1' o 'ansi'.")
    except Exception as e:
        print(f"❌ Ocurrió un error inesperado: {e}")

if __name__ == "__main__":
    acceder_con_pandas()

Para ir avanzando puedes analizar este script y aplicarlo a un caso real (un archivo csv como éste) para ver su funcionamiento. Esto es especialmente interesante su lo comparas con el funcionamiento de script basados en el módulo nativo CSV.

NOTA: Acuérdate de guardar tu cvs como librso3.csv dentro de una carpeta que deberás llamar datos o modificar la ruta de acceso de la instrucción ruta_archivo = 'datos\libros3.csv'

martes, 23 de septiembre de 2025

Datos. Archivos pdf

Biblioteca Camelot (I)

Tablas en pdf

Cuando trabajamos con documentos pdf, uno de los contenidos de especial interés y que además resulta especialmente complicado de manejar son las tablas.

Para acceder a su contenido podemos emplear recursos como PyPDF2, pero el resultado no es muy satisfactorio como hemos tenido ocasión de comprobar, así que decidí probar con otro recurso.

Realmente resulta muy complicado automatizar la extracción de datos de tablas de un documento pdf de forma que resulte preciso y funcional, y son precisamente las tablas las que mayor dificultad presentan. Camelot es una librería pensada específicamente para esta tarea y funciona satisfactoriamente, al menos con tablas sencillas y reales, no imágenes incrustadas.

Cierto es que trabajar con Camelot presenta cierta dificultad, incluyendo algunas complicaciones para su instalación, pero se pueden superar. Por eso te recomiendo que conozcas esta biblioteca por su fuente, su propia página web, incluyendo la lectura de su manual on-line. También combiene plantearse metas sencillas y trabajar con pdf también sencillos; al menos al principio. Ya podrás incrementar la dificultad conforme vayas dominando la herramienta.

En esta entrada te mostraré la que es posiblemente la forma más sencilla de abordar un problema básico: mostrar en pantalla el contenido de una tabla de un sencillo documento pdf de una página que contiene una tabla simple. Inmediatamente podremos pasar a cuestiones de mayor complejidad. Supongamos que ese documento pdf (tablaSimple.pdf) contiene esta tabla...

... a la que deseamos acceder desde un script de Python,concretamente desde este...



import camelot
# Especifica la ruta al archivo PDF
file_path = 'tablaSimple.pdf'
# Lee las tablas que contiene el PDF
tables = camelot.read_pdf(file_path)
# Imprime el número de tablas encontradas
print (f"Total de tablas encontradas: {tables.n}")
# Imprime el contenido de la primera tabla
print (tables[ 0 ].df)


... que nos devuelve esa misma tabla en el IDE Shell

Vistas así las cosas, la verdad es que este resultado parece bastante pobre, pero podemos hacer varias cosas a partir de aquí, entre otras pasar la tabla a un archivo Excel o trabajar directamente con el contenido de la tabla mediante librerías como Pandas .

En este caso vamos a importar la librería pandas, sin entrar ahora en más explicación, y añadir unas cuantas instrucciones más al script, por ejemplo acceder a la tabla capturada y pasar los datos a una colección como paso previo para manejarla, por ejemplo, accediendo a las "celdas" [1-0] y [1-1] y mostrando su contenido...



import pandas as pd
tabla = tables[0].df
nombre = tabla.iloc[1,0]
dato = tabla.iloc[1,1]
print(f'Nombre {nombre} - Edad {dato}')


... para obtener por pantalla Nombre Juan - Edad 23

Tampoco esto parece gran cosa, pero detrás de ello tenemos toda la potencia del manejo de datos que permiten librerías como Pandas y todas aquellas que facilitan el tratamiento de datos en Python. El que lo podamos conseguir partiendo de una tabla de datos de un documento pdf es gracias a Camelot, por lo que conocer esta biblioteca es una buena forma de empezar.